# Sum of a series

Compute the   nth   term of a series,   i.e. the sum of the   n   first terms of the corresponding sequence.

Sum of a series
You are encouraged to solve this task according to the task description, using any language you may know.

Informally this value, or its limit when   n   tends to infinity, is also called the sum of the series, thus the title of this task.

${\displaystyle S_{n}=\sum _{k=1}^{n}{\frac {1}{k^{2}}}}$

and compute   ${\displaystyle S_{1000}}$

This approximates the   zeta function   for   S=2,   whose exact value

${\displaystyle \zeta (2)={\pi ^{2} \over 6}}$

is the solution of the Basel problem.

## 11l

Translation of: Python
print(sum((1..1000).map(x -> 1.0/x^2)))
Output:
1.64393

## 360 Assembly

*        Sum of a series           30/03/2017
SUMSER   CSECT
USING  SUMSER,12          base register
LR     10,14              save r14
LE     4,=E'0'            s=0
LE     2,=E'1'            i=1
DO WHILE=(CE,2,LE,=E'1000') do i=1 to 1000
LER    0,2                  i
MER    0,2                  *i
LE     6,=E'1'              1
DER    6,0                  1/i**2
AER    4,6                  s=s+1/i**2
AE     2,=E'1'              i=i+1
ENDDO    ,                  enddo i
LA     0,4                format F13.4
LER    0,4                s
BAL    14,FORMATF         call formatf
MVC    PG(13),0(1)        retrieve result
XPRNT  PG,80              print buffer
BR     10                 exit
COPY   FORMATF            formatf code
PG       DC     CL80' '            buffer
END    SUMSER
Output:
1.6439

## ACL2

(defun sum-x^-2 (max-x)
(if (zp max-x)
0
(+ (/ (* max-x max-x))
(sum-x^-2 (1- max-x)))))

## Action!

INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

PROC Calc(CARD n REAL POINTER res)
CARD i,st
BYTE perc
REAL one,a,b

IntToReal(0,res)
IF n=0 THEN RETURN FI

IntToReal(1,one)
st=n/100
FOR i=1 TO n
DO
IF i MOD st=0 THEN
PrintB(perc) Put('%) PutE() Put(28)
perc==+1
FI

IntToReal(i,a)
RealMult(a,a,b)
RealDiv(one,b,a)
RealAssign(b,res)
OD
RETURN

PROC Main()
REAL POINTER res
CARD n=[1000]

Put(125) PutE() ;clear screen
Calc(n,res)
PrintF("s(%U)=",n)
PrintRE(res)
RETURN
Output:
s(1000)=1.64392967

## ActionScript

function partialSum(n:uint):Number
{
var sum:Number = 0;
for(var i:uint = 1; i <= n; i++)
sum += 1/(i*i);
return sum;
}
trace(partialSum(1000));

procedure Sum_Series is
function F(X : Long_Float) return Long_Float is
begin
return 1.0 / X**2;
end F;
use Lf_Io;
Sum : Long_Float := 0.0;
subtype Param_Range is Integer range 1..1000;
begin
for I in Param_Range loop
Sum := Sum + F(Long_Float(I));
end loop;
Put("Sum of F(x) from" & Integer'Image(Param_Range'First) &
" to" & Integer'Image(Param_Range'Last) & " is ");
Put(Item => Sum, Aft => 10, Exp => 0);
New_Line;
end Sum_Series;

## Aime

real
Invsqr(real n)
{
1 / (n * n);
}

integer
main(void)
{
integer i;
real sum;

sum = 0;

i = 1;
while (i < 1000) {
sum += Invsqr(i);
i += 1;
}

o_real(14, sum);
o_byte('\n');

0;
}

## ALGOL 68

MODE RANGE = STRUCT(INT lwb, upb);

PROC sum = (PROC (INT)LONG REAL f, RANGE range)LONG REAL:(
LONG REAL sum := LENG 0.0;
FOR i FROM lwb OF range TO upb OF range DO
sum := sum + f(i)
OD;
sum
);

test:(
RANGE range = (1,1000);
PROC f = (INT x)LONG REAL: LENG REAL(1) / LENG REAL(x)**2;
print(("Sum of f(x) from ", whole(lwb OF range, 0), " to ",whole(upb OF range, 0)," is ", fixed(SHORTEN sum(f,range),-8,5),".", new line))
)

Output:

Sum of f(x) from 1 to 1000 is  1.64393.

## ALGOL W

Uses Jensen's Device (first introduced in Algol 60) which uses call by name to allow a summation index and the expression to sum to be specified as parameters to a summation procedure.

begin % compute the sum of 1/k^2 for k = 1..1000 %
integer k;
% computes the sum of a series from lo to hi using Jensen's Device %
real procedure sum  ( integer %name% k; integer value lo, hi; real procedure term );
begin
real temp;
temp := 0;
k := lo;
while k <= hi do begin
temp := temp + term;
k := k + 1
end while_k_le_temp;
temp
end;
write( r_format := "A", r_w := 8, r_d := 5, sum( k, 1, 1000, 1 / ( k * k ) ) )
end.
Output:
1.64393

+/÷2*1000
1.64393

## AppleScript

Translation of: JavaScript
----------------------- SUM OF SERIES ----------------------

-- seriesSum :: Num a => (a -> a) -> [a] -> a
on seriesSum(f, xs)
script go
property mf : |λ| of mReturn(f)
on |λ|(a, x)
a + mf(x)
end |λ|
end script

foldl(go, 0, xs)
end seriesSum

---------------------------- TEST --------------------------

-- inverseSquare :: Num -> Num
on inverseSquare(x)
1 / (x ^ 2)
end inverseSquare

on run
seriesSum(inverseSquare, enumFromTo(1, 1000))

--> 1.643934566682
end run

--------------------- GENERIC FUNCTIONS --------------------

-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m  n then
set lst to {}
repeat with i from m to n
set end of lst to i
end repeat
lst
else
{}
end if
end enumFromTo

-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl

-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
Output:
1.643934566682

## Arturo

series: map 1..1000 => [1.0/&^2]
print [sum series]
Output:
1.643934566681561

## Asymptote

real sum;
for(int i = 1; i < 1000; ++i)  sum = sum + 1 / (i * i);
write(sum, suffix=none);
Output:
1.64393356668156

## AutoHotkey

AutoHotkey allows the precision of floating point numbers generated by math operations to be adjusted via the SetFormat command. The default is 6 decimal places.

SetFormat, FloatFast, 0.15
While A_Index <= 1000
sum += 1/A_Index**2
MsgBox,% sum  ;1.643934566681554

## AWK

$awk 'BEGIN{for(i=1;i<=1000;i++)s+=1/(i*i);print s}' 1.64393 ## BASIC Works with: QuickBasic version 4.5 function s(x%) s = 1 / x ^ 2 end function function sum(low%, high%) ret = 0 for i = low to high ret = ret + s(i) next i sum = ret end function print sum(1, 1000) ### BASIC256 Works with: True BASIC function sumSeries(n) if n = 0 then sumSeries = 0 let sum = 0 for k = 1 to n let sum = sum + 1 / k ^ 2 next k sumSeries = sum end function print "s(1000) = "; sumSeries(1000) print "zeta(2) = "; pi * pi / 6 end ### BBC BASIC FOR i% = 1 TO 1000 sum += 1/i%^2 NEXT PRINT sum ### Gambas Public Sub Main() Print "s(1000) = "; sumSeries(1000) Print "zeta(2) = "; Pi * Pi / 6 End Function sumSeries(n As Integer) As Float If n = 0 Then Return 0 Dim sum As Float = 0 For k As Integer = 1 To n sum += 1.0 / (k * k) Next Return sum End Function ### QBasic Works with: QBasic version 1.1 Works with: QuickBasic version 4.5 FUNCTION sumSeries# (n) IF n = 0 THEN sunSeries = 0 FOR k = 1 TO n sum# = sum# + 1! / (k * k) NEXT sumSeries# = sum# END FUNCTION pi# = 4 * ATN(1) PRINT "s(1000) = "; sumSeries#(1000) PRINT "zeta(2) = "; pi# * pi# / 6 END ### True BASIC Works with: BASIC256 FUNCTION sumSeries(n) IF n = 0 then LET sumSeries = 0 END IF LET sum = 0 FOR k = 1 to n LET sum = sum + 1 / k ^ 2 NEXT k LET sumSeries = sum END FUNCTION PRINT "s(1000) = "; sumSeries(1000) PRINT "zeta(2) = "; pi * pi / 6 END ### XBasic Works with: Windows XBasic PROGRAM "SumOfASeries" VERSION "0.0000" DECLARE FUNCTION Entry () DECLARE FUNCTION sumSeries#(n) FUNCTION Entry () pi# = 3.1415926535896 PRINT "s(1000) = "; sumSeries#(1000) PRINT "zeta(2) = "; pi# * pi# / 6 END FUNCTION FUNCTION sumSeries#(n) IF n = 0 THEN RETURN 0 sum# = 0 FOR k = 1 TO n sum# = sum# + 1.0/(k * k) NEXT RETURN sum# END FUNCTION END PROGRAM ### Yabasic sub sumSeries(n) if n = 0 then return 0 : fi sum = 0 for k = 1 to n sum = sum + 1 / k ^ 2 next k return sum end sub print "s(1000) = ", sumSeries(1000) print "zeta(2) = ", pi * pi / 6 end ## bc define f(x) { return(1 / (x * x)) } define s(n) { auto i, s for (i = 1; i <= n; i++) { s += f(i) } return(s) } scale = 20 s(1000) Output: 1.64393456668155979824 ## Beads beads 1 program 'Sum of a series' calc main_init var k = 0 loop reps:1000 count:n k = k + 1/n^2 log to_str(k) Output: 1.6439345666815615 ## Befunge Emulates fixed point arithmetic with a 32 bit integer so the result is not very accurate. 05558***>::"~"%00p"~"/10p"( }}2"*v v*8555$_^#!:-1+*"~"g01g00+/*:\***<
<@$_,#!>#:<+*<v+*86%+55:p00<6\0/** "."\55+%68^>\55+/00g1-:#^_$
Output:
1.643934

## BQN

√⁼ here reads as the inverse of the square root, which can be changed to 2⋆˜ or ×˜. It has been used here since it is the most intuitive.

+´÷√1+↕1000
1.6439345666815597

## Bracmat

( 0:?i
& 0:?S
& whl'(1+!i:~>1000:?i&!i^-2+!S:?S)
& out$!S & out$(flt$(!S,10)) ); Output: 8354593848314...../5082072010432..... (1732 digits and a slash) 1,6439345667*10E0 ## Brat p 1.to(1000).reduce 0 { sum, x | sum + 1.0 / x ^ 2 } #Prints 1.6439345666816 ## C #include <stdio.h> double Invsqr(double n) { return 1 / (n*n); } int main (int argc, char *argv[]) { int i, start = 1, end = 1000; double sum = 0.0; for( i = start; i <= end; i++) sum += Invsqr((double)i); printf("%16.14f\n", sum); return 0; } ## C# class Program { static void Main(string[] args) { // Create and fill a list of number 1 to 1000 List<double> myList = new List<double>(); for (double i = 1; i < 1001; i++) { myList.Add(i); } // Calculate the sum of 1/x^2 var sum = myList.Sum(x => 1/(x*x)); Console.WriteLine(sum); Console.ReadLine(); } } An alternative approach using Enumerable.Range() to generate the numbers. class Program { static void Main(string[] args) { double sum = Enumerable.Range(1, 1000).Sum(x => 1.0 / (x * x)); Console.WriteLine(sum); Console.ReadLine(); } } ## C++ #include <iostream> double f(double x); int main() { unsigned int start = 1; unsigned int end = 1000; double sum = 0; for( unsigned int x = start; x <= end; ++x ) { sum += f(x); } std::cout << "Sum of f(x) from " << start << " to " << end << " is " << sum << std::endl; return 0; } double f(double x) { return ( 1.0 / ( x * x ) ); } ## CLIPS (deffunction S (?x) (/ 1 (* ?x ?x))) (deffunction partial-sum-S (?start ?stop) (bind ?sum 0) (loop-for-count (?i ?start ?stop) do (bind ?sum (+ ?sum (S ?i))) ) (return ?sum) ) Usage: CLIPS> (partial-sum-S 1 1000) 1.64393456668156 ## Clojure (reduce + (map #(/ 1.0 % %) (range 1 1001))) ## CLU series_sum = proc (from, to: int, fn: proctype (real) returns (real)) returns (real) sum: real := 0.0 for i: int in int$from_to(from, to) do
sum := sum + fn(real$i2r(i)) end return(sum) end series_sum one_over_k_squared = proc (k: real) returns (real) return(1.0 / (k * k)) end one_over_k_squared start_up = proc () po: stream := stream$primary_output()
result: real := series_sum(1, 1000, one_over_k_squared)
stream$putl(po, f_form(result, 1, 6)) end start_up Output: 1.643935 ## COBOL IDENTIFICATION DIVISION. PROGRAM-ID. sum-of-series. DATA DIVISION. WORKING-STORAGE SECTION. 78 N VALUE 1000. 01 series-term USAGE FLOAT-LONG. 01 i PIC 9(4). PROCEDURE DIVISION. PERFORM VARYING i FROM 1 BY 1 UNTIL N < i COMPUTE series-term = series-term + (1 / i ** 2) END-PERFORM DISPLAY series-term GOBACK . Output: 1.643933784000000120 ## CoffeeScript console.log [1..1000].reduce((acc, x) -> acc + (1.0 / (x*x))) ## Common Lisp (loop for x from 1 to 1000 summing (expt x -2)) ## Crystal Translation of: Ruby puts (1..1000).sum{ |x| 1.0 / x ** 2 } puts (1..5000).sum{ |x| 1.0 / x ** 2 } puts (1..9999).sum{ |x| 1.0 / x ** 2 } puts Math::PI ** 2 / 6 Output: 1.6439345666815615 1.6447340868469014 1.6448340618480652 1.6449340668482264 ## D ### More Procedural Style import std.stdio, std.traits; ReturnType!TF series(TF)(TF func, int end, int start=1) pure nothrow @safe @nogc { typeof(return) sum = 0; foreach (immutable i; start .. end + 1) sum += func(i); return sum; } void main() { writeln("Sum: ", series((in int n) => 1.0L / (n ^^ 2), 1_000)); } Output: Sum: 1.64393 ### More functional Style Same output. import std.stdio, std.algorithm, std.range; enum series(alias F) = (in int end, in int start=1) pure nothrow @nogc => iota(start, end + 1).map!F.sum; void main() { writeln("Sum: ", series!q{1.0L / (a ^^ 2)}(1_000)); } ## dc 20 k 0 [ln 1 + d sn _2 ^ + 1000 ln <l] d sl x p Output: 1.64393456668155979824 ## Dart Translation of: Scala main() { var list = new List<int>.generate(1000, (i) => i + 1); num sum = 0; (list.map((x) => 1.0 / (x * x))).forEach((num e) { sum += e; }); print(sum); } Translation of: F# f(double x) { if (x == 0) return x; else return (1.0 / (x * x)) + f(x - 1.0); } main() { print(f(1000)); } ## Delphi unit Form_SumOfASeries_Unit; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TFormSumOfASeries = class(TForm) M_Log: TMemo; B_Calc: TButton; procedure B_CalcClick(Sender: TObject); private { Private-Deklarationen } public { Public-Deklarationen } end; var FormSumOfASeries: TFormSumOfASeries; implementation {$R *.dfm}

function Sum_Of_A_Series(_from,_to:int64):extended;
begin
result:=0;
while _from<=_to do
begin
result:=result+1.0/(_from*_from);
inc(_from);
end;
end;

procedure TFormSumOfASeries.B_CalcClick(Sender: TObject);
begin
try
except
end;
end;

end.
Output:
1.64393456668156

## DWScript

var s : Float;
for var i := 1 to 1000 do
s += 1 / Sqr(i);

PrintLn(s);

## Dyalect

Translation of: Swift
func Integer.SumSeries() {
var ret = 0

for i in 1..this {
ret += 1 / pow(Float(i), 2)
}

ret
}

var x = 1000
print(x.SumSeries())
Output:
1.6439345666815615

## E

pragma.enable("accumulator")
accum 0 for x in 1..1000 { _ + 1 / x ** 2 }

## EasyLang

numfmt 8 0
for i = 1 to 1000
s += 1 / (i * i)
.
print s

## EchoLisp

(lib 'math) ;; for (sigma f(n) nfrom nto) function
(Σ (λ(n) (// (* n n))) 1 1000)
;; or
(sigma (lambda(n) (// (* n n))) 1 1000)
1.6439345666815615

(// (* PI PI) 6)
1.6449340668482264

## EDSAC order code

Real numbers on EDSAC were restricted to the range -1 <= x < 1. The posted solution cheats slightly by omitting the term with k = 1, while printing '1' before the decimal part. The first eight decimals of the output are correct; the last two should be 67 not 41.

In floating-point arithmetic, summing the smallest terms first is more accurate than summing the largest terms first, as can be seen e.g. in the Pascal solution. EDSAC used fixed-point arithmetic, so the order of summation makes no difference.

[Sum of a series, Rosetta Code website.
EDSAC program, Initial Orders 2.]
..PZ  [blank tape and terminator]

[Library subroutine D6 - Division, accurate, fast.
36 locations, working positons 6D and 8D.
C(0D) := C(0D)/C(4D), where C(4D) <> 0, -1.]
T56K
T6DE25@U8DN8DA6DT6DH6DS6DN4DA4DYFG21@SDVDTDEFW1526D

[Library subroutine P1 - Print positive number, no formatting or round-off.
Prints number in 0D to n places of decimals, where n is specified by 'P n F'
pseudo-order after subroutine call.  21 locations.]
T92K
GKA18@U17@S20@T5@H19@PFT5@VDUFOFFFSFL4FTDA5@A2FG6@EFU3FJFM1F

[Custom subroutine to calculate 1/k^2 for a 17-bit integer k > 1.
Input:  0F = k (with the usual scaling; actually k/(2^16).
Output: 0D = 1/k^2.]
T120K  GK
HF          [multiply register := k/(2^16)]
VF          [acc := k/(2^16) squared]
[At this point acc =(k^2)/(2^32). Now we switch to 35-bit
arithmetic, in which integers are scaled by 2^(-34)]
R1F         [shift acc 2 right to adjust scaling]
T4D         [4D := k^2]
TD          [set 0D := 0; clears "sandwich bit" between 0F and 1F]
A12@  TF    [set 0D := 1 by setting 0F := 1]
A9@  G56F   [call EDSAC library subroutine for division]
[11]   ZF          [overwritten by jump back to caller]
[12]   PD          [short constant 1]

[Main program]
T200K  GK   [load at even address because of long variable at 0]
[0]   PF  PF      [build sum here]
[2]   PD          [short constant 1]
[3]   P500F       [short constant 1000]
[4]   K2048F  #F  !F  @F  &F  [letters, figures, space, CR, LF]
[9]   HF  IF  LF  [letters H, I, L (in letters mode)]
[12]   QF  MF      [digit 1, dot (in figures mode)]
[14]   PF          [variable k]

[15]   T#@  A2@ T14@            [sum := 0, k := 1]
[18]   TF  A14@  A2@  U14@  TF  [inc k; pass new k to function in 0F]
A23@  G120F              [call function; places 1/k^2 at 0D]
A14@  S3@  G18@          [test for k = maximum, loop back if not]
O4@  O11@  O89@  O6@  O15@  O89@  O6@  O9@  O10@  O6@  [print 'LO TO HI ']
O5@  O12@  O13@          [print '1.']
A#@  TD  A46@  G92F      [call subroutine to print decimal part]
P10F                     [parameter for print subroutine; 10 decimal places]
O7@  O8@                 [print CR, LF]

[Sum in reverse order to confirm that the result is identical on EDSAC.
Not much different from the above, so given in condensed form.]
O4@O9@O10@O6@O15@O89@O6@O11@O89@O6@O5@O12@O13@A84@G92FP10FO7@O8@

[89]   O5@  ZF                  [flush teleprinter buffer; stop]
E15Z  PF                 [define entry point; enter with acc = 0]
Output:
LO TO HI 1.6439345641
HI TO LO 1.6439345641

## Eiffel

note
description: "Compute the n-th term of a series"

class
SUM_OF_SERIES_EXAMPLE

inherit
MATH_CONST

create
make

feature -- Initialization

make
local
approximated, known: REAL_64
do
known := Pi^2 / 6

approximated := sum_until (agent g, 1001)
print ("%Nzeta function exact value: %N")
print (known)
print ("%Nzeta function approximated value: %N")
print (approximated)
end

feature -- Access

g (k: INTEGER): REAL_64
-- 'k'-th term of the serie
require
k_positive: k > 0
do
Result := 1 / (k * k)
end

sum_until (s: FUNCTION [ANY, TUPLE [INTEGER], REAL_64]; n: INTEGER): REAL_64
-- sum of the 'n' first terms of 's'
require
n_positive: n > 0
one_parameter: s.open_count = 1
do
Result := 0
across 1 |..| n as it loop
Result := Result + s.item ([it.item])
end
end

end

## Elena

ELENA 6.x :

import system'routines;
import extensions;

public program()
{
var sum := new Range(1, 1000).selectBy::(x => 1.0r / (x * x)).summarize(new Real());

console.printLine(sum)
}
Output:
1.643933566682

## Elixir

iex(1)> Enum.reduce(1..1000, 0, fn x,sum -> sum + 1/(x*x) end)
1.6439345666815615

## Elm

module Main exposing (main)

import Html exposing (h1, div, p, text)
import Html.Attributes exposing (style)

aList : List Int
aList = List.range 1 1000

-- version a with a list
k2xSum : Float
k2xSum = List.sum
<| List.map (\x -> 1.0 / x / x )
<| List.map (\n -> toFloat n) aList

-- version b with a list
fx : Int -> Float
fx =
(\n -> toFloat n |> \m -> 1.0 / m / m)

f2kSum : Float
f2kSum = List.sum
<| List.map fx aList

-- version with recursion, without a list
untilMax : Int -> Int -> Float -> Float
untilMax k kmax accum =
if k > kmax
then accum
else
let
x = toFloat k
dx = 1.0 / x / x
in  untilMax (k + 1)  kmax (accum + dx)

recSum : Float
recSum = untilMax 1 1000 0.0

main = div [style "margin" "5%", style "color" "blue"] [
h1 [] [text "Sum of series Σ 1/k²"]
, text (" Version a with a list: Sum = " ++ String.fromFloat k2xSum)
, p [] [text (" Version b with a list: Sum = " ++ String.fromFloat f2kSum)]
, p [] [text (" Recursion version c: Sum = " ++ String.fromFloat recSum)]
]
Output:
Sum of series Σ 1/k²
Version a with a list: Sum = 1.6439345666815615

Version b with a list: Sum = 1.6439345666815615

Recursion version c: Sum = 1.6439345666815615

## Emacs Lisp

(defun series (n)
(when (<= n 0)
(user-error "n must be positive"))
(apply #'+ (mapcar (lambda (k) (/ 1.0 (* k k))) (number-sequence 1 n))))

(format "%.10f" (series 1000)) ;=> "1.6439345667"

## Erlang

lists:sum([1/math:pow(X,2) || X <- lists:seq(1,1000)]).

## Euphoria

Works with: Euphoria version 4.0.0

This is based on the BASIC example.

function s( atom x )
return 1 / power( x, 2 )
end function

function sum( atom low, atom high )
atom ret = 0.0
for i = low to high do
ret = ret + s( i )
end for
return ret
end function

printf( 1, "%.15f\n", sum( 1, 1000 ) )

## Excel

### LAMBDA

Binding the names sumOfSeries, and inverseSquare to the following lambda expressions in the Name Manager of the Excel WorkBook:

Excel automatically lifts a function over a scalar to a function over an array:

sumOfSeries
=LAMBDA(f,
LAMBDA(n,
SUM(
f(SEQUENCE(n, 1, 1, 1))
)
)
)

inverseSquare
=LAMBDA(n,
1 / (n ^ 2)
)
Output:
 =sumOfSeries(inverseSquare)(A2) fx A B 1 N terms Sum of inverse square series 2 1 1 3 10 1.5497677311665408 4 100 1.63498390018489 5 1000 1.64393456668156

## Ezhil

## இந்த நிரல் தொடர் கூட்டல் (Sum Of Series) என்ற வகையைச் சேர்ந்தது

## இந்த நிரல் ஒன்று முதல் தரப்பட்ட எண் வரை 1/(எண் * எண்) எனக் கணக்கிட்டுக் கூட்டி விடை தரும்

நிரல்பாகம் தொடர்க்கூட்டல்(எண்1)

எண்2 = 0

@(எண்3 = 1, எண்3 <= எண்1, எண்3 = எண்3 + 1) ஆக

## ஒவ்வோர் எண்ணின் வர்க்கத்தைக் கணக்கிட்டு, ஒன்றை அதனால் வகுத்துக் கூட்டுகிறோம்

எண்2 = எண்2 + (1 / (எண்3 * எண்3))

முடி

பின்கொடு (எண்2)

முடி

= int(உள்ளீடு("ஓர் எண்ணைச் சொல்லுங்கள்: "))

பதிப்பி "நீங்கள் தந்த எண் "
பதிப்பி "அதன் தொடர்க் கூட்டல் " தொடர்க்கூட்டல்()

## F#

The following function will do the task specified.

let rec f (x : float) =
match x with
| 0. -> x
| x -> (1. / (x * x)) + f (x - 1.)

In the interactive F# console, using the above gives:

> f 1000. ;;
val it : float = 1.643934567

However, this recursive function will run out of stack space eventually (try 100000). A tail-recursive implementation will not consume stack space and can therefore handle much larger ranges. Here is such a version:

#light
let sum_series (max : float) =
let rec f (a:float, x : float) =
match x with
| 0. -> a
| x -> f ((1. / (x * x) + a), x - 1.)
f (0., max)

[<EntryPoint>]
let main args =
let (b, max) = System.Double.TryParse(args.[0])
printfn "%A" (sum_series max)
0

This block can be compiled using fsc --target exe filename.fs or used interactively without the main function.

For a much more elegant and FP style of solving this problem, use:

Seq.sum [for x in [1..1000] do 1./(x * x |> float)]

## Factor

1000 [1,b] [ >float sq recip ] map-sum

## Fantom

Within 'fansh':

fansh> (1..1000).toList.reduce(0.0f) |Obj a, Int v -> Obj| { (Float)a + (1.0f/(v*v)) }
1.6439345666815615

## Fermat

Sigma<k=1,1000>[1/k^2]
Output:
83545938483149689478187854264854884386044454314086472930763839512603803291207881839588904977469387999844962675327115010933 
903589145654299730231109091124308462732153297321867661093162618281746011828755017021645889046777854795025297006943669294
330752479399654716368801794529682603741344724733173765262964463970763934463926259796895140901128384286333311745462863716 
753134735154188954742414035836608258393970996630553795415075904205673610359458498106833291961256452756993199997231825920
203667952667546787052535763624910912251107083702817265087341966845358732584971361645348091123849687614886682117125784781 
422103460192439394780707024963279033532646857677925648889105430050030795563141941157379481719403833258405980463950499887
302926152552848089894630843538497552630691676216896740675701385847032173192623833881016332493844186817408141003602396236 
858699094240207812766449 / 50820720104325812617835292273000760481839790754374852703215456050992581046448162621598030244504097
240825920773913981926305208272518886258627010933716354037062979680120674828102224650586465553482032614190502746121717248 
161892239954030493982549422690846180552358769564169076876408783086920322038142618269982747137757706040198826719424371333
781947889528085329853597116893889786983109597085041878513917342099206896166585859839289193299599163669641323895022932959 
750057616390808553697984192067774252834860398458100840611325353202165675189472559524948330224159123505567527375848194800
452556940453530457590024173749704941834382709198515664897344438584947842793131829050180589581507273988682409028088248800 
576590497216884808783192565859896957125449502802395453976401743504938336291933628859306247684023233969172475385327442707
968328512729836445886537101453118476390400000000;  or  1.6439345666815598031390580238222155896521

prompt$./sumOfSeries ζ(2) approximation: 1.643934566681561 π² / 6 : 1.644934066848226 ## GEORGE 0 (s) 1, 1000 rep (i) s 1 i dup × / + (s) ; ] P Output:- 1.643934566681561 ## Go package main import ("fmt"; "math") func main() { fmt.Println("known: ", math.Pi*math.Pi/6) sum := 0. for i := 1e3; i > 0; i-- { sum += 1 / (i * i) } fmt.Println("computed:", sum) } Output: known: 1.6449340668482264 computed: 1.6439345666815597 ## Groovy Start with smallest terms first to minimize rounding error: println ((1000..1).collect { x -> 1/(x*x) }.sum()) Output: 1.6439345654 ## Haskell With a list comprehension: sum [1 / x ^ 2 | x <- [1..1000]] With higher-order functions: sum$ map (\x -> 1 / x ^ 2) [1..1000]

In point-free style:

(sum . map (1/) . map (^2)) [1..1000]

or

(sum . map ((1 /) . (^ 2))) [1 .. 1000]

or, as a single fold:

seriesSum f = foldr ((+) . f) 0

inverseSquare = (1 /) . (^ 2)

main :: IO ()
main = print $seriesSum inverseSquare [1 .. 1000] Output: 1.6439345666815615 ## Haxe ### Procedural using StringTools; class Main { static function main() { var sum = 0.0; for (x in 1...1001) sum += 1.0/(x * x); Sys.println('Approximation:$sum');
Sys.println('Exact: '.lpad(' ', 15) + Math.PI * Math.PI / 6);
}
}
Output:
Approximation: 1.64393456668156146
Exact: 1.64493406684822641

### Functional

using Lambda;
using StringTools;

class Main {
static function main() {
var approx = [for (x in 1...1001) x].fold(function(x, sum) return sum += 1.0 / (x * x), 0);
Sys.println('Approximation: $approx'); Sys.println('Exact: '.lpad(' ', 15) + Math.PI * Math.PI / 6); } } Output: Same as for procedural ## HicEst REAL :: a(1000) a = 1 /$^2
WRITE(ClipBoard, Format='F17.15') SUM(a)
1.643934566681561

## Icon and Unicon

procedure main()
local i, sum
sum := 0 & i := 0
every sum +:= 1.0/((| i +:= 1 ) ^ 2) \1000
write(sum)
end

or

procedure main()
every (sum := 0) +:= 1.0/((1 to 1000)^2)
write(sum)
end

Note: The terse version requires some explanation. Icon expressions all return values or references if they succeed. As a result, it is possible to have expressions like these below:

x := y := 0   # := is right associative so, y is assigned 0, then x
1 < x < 99    # comparison operators are left associative so, 1 < x returns x (if it is greater than 1), then x < 99 returns 99 if the comparison succeeds
(sum := 0)    # returns a reference to sum which can in turn be used with augmented assignment +:=

## IDL

print,total( 1/(1+findgen(1000))^2)

## Io

Io 20110905
Io> sum := 0 ; Range 1 to(1000) foreach(k, sum = sum + 1/(k*k))
==> 1.6439345666815615
Io> 1 to(1000) map(k, 1/(k*k)) sum
==> 1.6439345666815615
Io>

The expression using map generates a list internally. Using foreach does not.

## J

NB. sum of reciprocals of squares of first thousand positive integers
+/ % *: >: i. 1000
1.64393

(*:o.1)%6       NB. pi squared over six, for comparison
1.64493

1r6p2           NB.  As a constant (J has a rich constant notation)
1.64493

## Java

public class Sum{
public static double f(double x){
return 1/(x*x);
}

public static void main(String[] args){
double start = 1;
double end = 1000;
double sum = 0;

for(double x = start;x <= end;x++) sum += f(x);

System.out.println("Sum of f(x) from " + start + " to " + end +" is " + sum);
}
}

## JavaScript

### ES5

function sum(a,b,fn) {
var s = 0;
for ( ; a <= b; a++) s += fn(a);
return s;
}

sum(1,1000, function(x) { return 1/(x*x) } )  // 1.64393456668156

or, in a functional idiom:

(function () {

function sum(fn, lstRange) {
return lstRange.reduce(
function (lngSum, x) {
return lngSum + fn(x);
}, 0
);
}

function range(m, n) {
return Array.apply(null, Array(n - m + 1)).map(function (x, i) {
return m + i;
});
}

return sum(
function (x) {
return 1 / (x * x);
},
range(1, 1000)
);

})();
Output:
1.6439345666815615

### ES6

(() => {
'use strict';

// SUM OF A SERIES -------------------------------------------------------

// seriesSum :: Num a => (a -> a) -> [a] -> a
const seriesSum = (f, xs) =>
foldl((a, x) => a + f(x), 0, xs);

// GENERIC ---------------------------------------------------------------

// enumFromToInt :: Int -> Int -> [Int]
const enumFromTo = (m, n) =>
Array.from({
length: Math.floor(n - m) + 1
}, (_, i) => m + i);

// foldl :: (b -> a -> b) -> b -> [a] -> b
const foldl = (f, a, xs) => xs.reduce(f, a);

// TEST ------------------------------------------------------------------

return seriesSum(x => 1 / (x * x), enumFromTo(1, 1000));
})();
Output:
1.6439345666815615

## Joy

1000 [0] [swap -2 pow +] primrec.
Output:
1.64393

## jq

The jq idiom for efficient computation of this kind of sum is to use "reduce", either directly or using a summation wrapper function.

Directly:

def s(n): reduce range(1; n+1) as $k (0; . + 1/($k * $k) ); s(1000) Output: 1.6439345666815615 Using a generic summation wrapper function allows problems specified in "sigma" notation to be solved using syntax that closely resembles that notation: def summation(s): reduce s as$k (0; . + $k); summation( range(1; 1001) | (1/(. * .) ) ) An important point is that nothing is lost in efficiency using the declarative and quite elegant approach using "summation". ## Jsish From Javascript ES5. #!/usr/bin/jsish /* Sum of a series */ function sum(a:number, b:number , fn:function):number { var s = 0; for ( ; a <= b; a++) s += fn(a); return s; } ;sum(1, 1000, function(x) { return 1/(x*x); } ); /* =!EXPECTSTART!= sum(1, 1000, function(x) { return 1/(x*x); } ) ==> 1.643934566681561 =!EXPECTEND!= */ Output: prompt$ jsish --U sumOfSeries.jsi
sum(1, 1000, function(x) { return 1/(x*x); } ) ==> 1.643934566681561

## Julia

Using a higher-order function:

julia> sum(k -> 1/k^2, 1:1000)
1.643934566681559

julia> pi^2/6
1.6449340668482264

A simple loop is more optimized:

julia> function f(n)
s = 0.0
for k = 1:n
s += 1/k^2
end
return s
end

julia> f(1000)
1.6439345666815615

ssr: +/1%_sqr
ssr 1+!1000
1.643935

## Kotlin

// version 1.0.6

fun main(args: Array<String>) {
val n = 1000
val sum = (1..n).sumByDouble { 1.0 / (it * it) }
println("Actual sum is $sum") println("zeta(2) is${Math.PI * Math.PI / 6.0}")
}
Output:
Actual sum is 1.6439345666815615
zeta(2)    is 1.6449340668482264

## Lambdatalk

{+ {S.map {lambda {:k} {/ 1 {* :k :k}}} {S.serie 1 1000}}}
-> 1.6439345666815615 ~  1.6449340668482264 = PI^2/6

## Lang5

1000 iota 1 + 1 swap / 2 ** '+ reduce .

## langur

val pi = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214

writeln "calc.: ", fold(fn{+}, map(fn x:1/x^2, 1..1000))
writeln "known: ", pi^2/6
Output:
calc.: 1.643934566681559803139058023822206
known: 1.644934066848226436472415166646025

If we set a higher arbitrary maximum for division, we get more digits.

val pi = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214

mode divMaxScale = 100

writeln "calc.: ", fold(fn{+}, map(fn x:1/x^2, 1..1000))
writeln "known: ", pi^2/6
Output:
calc.: 1.6439345666815598031390580238222155896521034464936853167172372054281147052136371544864376381235947140
known: 1.6449340668482264364724151666460251892189499012067984377355582293700074704032008738336289006197587053

## Lasso

define sum_of_a_series(n::integer,k::integer) => {
local(sum = 0)
loop(-from=#k,-to=#n) => {
#sum += 1.00/(math_pow(loop_count,2))
}
return #sum
}
sum_of_a_series(1000,1)
Output:
1.643935

## LFE

### With lists:foldl

(defun sum-series (nums)
(lists:foldl
#'+/2
0
(lists:map
(lambda (x) (/ 1 x x))
nums)))

### With lists:sum

(defun sum-series (nums)
(lists:sum
(lists:map
(lambda (x) (/ 1 x x))
nums)))

Both have the same result:

> (sum-series (lists:seq 1 100000))
1.6449240668982423

## Liberty BASIC

for i =1 to 1000
sum =sum +1 /( i^2)
next i

print sum

end

## Lingo

the floatprecision = 8
sum = 0
repeat with i = 1 to 1000
sum = sum + 1/power(i, 2)
end repeat
put sum
-- 1.64393457

## LiveCode

repeat with i = 1 to 1000
end repeat
put summ  //1.643935

## Logo

to series :fn :a :b
localmake "sigma 0
for [i :a :b] [make "sigma :sigma + invoke :fn :i]
output :sigma
end
to zeta.2 :x
output 1 / (:x * :x)
end
print series "zeta.2 1 1000
make "pi (radarctan 0 1) * 2
print :pi * :pi / 6

## Lua

sum = 0
for i = 1, 1000 do sum = sum + 1/i^2 end
print(sum)

## Lucid

series = ssum asa  n >= 1000
where
num = 1 fby num + 1;
ssum = ssum + 1/(num * num)
end;

## Maple

sum(1/k^2, k=1..1000);
Output:
-Psi(1, 1001)+(1/6)*Pi^2

## Mathematica/Wolfram Language

This is the straightforward solution of the task:

Sum[1/x^2, {x, 1, 1000}]

However this returns a quotient of two huge integers (namely the exact sum); to get a floating point approximation, use N:

N[Sum[1/x^2, {x, 1, 1000}]]

or better:

NSum[1/x^2, {x, 1, 1000}]

Which gives a higher or equal accuracy/precision. Alternatively, get Mathematica to do the whole calculation in floating point by using a floating point value in the formula:

Sum[1./x^2, {x, 1, 1000}]

Other ways include (exact, approximate,exact,approximate):

Total[Table[1/x^2, {x, 1, 1000}]]
Total[Table[1./x^2, {x, 1, 1000}]]
Plus@@Table[1/x^2, {x, 1, 1000}]
Plus@@Table[1./x^2, {x, 1, 1000}]

## MATLAB

sum([1:1000].^(-2))

## Maxima

(%i45) sum(1/x^2, x, 1, 1000);
835459384831496894781878542648[806 digits]396236858699094240207812766449
(%o45) ------------------------------------------------------------------------
508207201043258126178352922730[806 digits]886537101453118476390400000000

(%i46) sum(1/x^2, x, 1, 1000),numer;
(%o46) 1.643934566681561

## MAXScript

total = 0
for i in 1 to 1000 do
(
total += 1.0 / pow i 2
)
print total

## min

Works with: min version 0.19.3
0 1 (
((dup * 1 swap /) (id)) cleave
) 1000 times pop print
Output:
1.643934566681562

## MiniScript

zeta = function(num)
return 1 / num^2
end function

sum = function(start, finish, formula)
total = 0
for i in range(start, finish)
total = total + formula(i)
end for
end function

print sum(1, 1000, @zeta)
Output:
1.643935

## МК-61/52

0	П0	П1	ИП1	1	+	П1	x^2	1/x	ИП0
+	П0	ИП1	1	0	0	0	-	x>=0	03
ИП0	С/П

## ML

### Standard ML

(* 1.64393456668 *)
List.foldl op+ 0.0 (List.tabulate(1000, fn x => 1.0 / Math.pow(real(x + 1),2.0)))

### mLite

println  fold (+, 0)  map (fn x = 1 / x ^ 2)  iota (1,1000);

Output:

1.6439345666815549

## MMIX

x	IS	$1 % flt calculations y IS$2	%   id
z	IS	$3 % z = sum series t IS$4	% temp var

LOC	Data_Segment
GREG	@
BUF	OCTA	0,0,0		% print buffer

LOC	#1000
GREG	@

// print floating point number in scientific format: 0.xxx...ey..
// most of this routine is adopted from:
// http://www.pspu.ru/personal/eremin/emmi/rom_subs/printreal.html
// float number in z
GREG	@
NaN	BYTE	"NaN..",0
NewLn	BYTE	#a,0
1H	LDA	x,NaN
TRAP	0,Fputs,StdOut
GO	$127,$127,0

prtFlt	FUN	x,z,z		% test if z == NaN
BNZ	x,1B
CMP	$73,z,0 % if necessary remember it is neg BNN$73,4F
Sign	BYTE	'-'
LDA	$255,Sign TRAP 0,Fputs,StdOut ANDNH z,#8000 % make number pos // normalizing float number 4H SETH$74,#4024	% initialize mulfactor = 10.0
SETH	$73,#0023 INCMH$73,#86f2
INCML	$73,#6fc1 % FLOT$73,$73 %$73 = float 10^16
SET	$75,16 % set # decimals to 16 8H FCMP$72,z,$73 % while z >= 10^16 do BN$72,9F		%
FDIV	z,z,$74 % z = z / 10.0 ADD$75,$75,1 % incr exponent JMP 8B % wend 9H FDIV$73,$73,$74	% 10^16 / 10.0
5H	FCMP	$72,z,$73	% while z < 10^15 do
BNN	$72,6F FMUL z,z,$74		%  z = z * 10.0
SUB	$75,$75,1	%  exp = exp - 1
JMP	5B
NulPnt	BYTE	'0','.',#00
6H	LDA	$255,NulPnt % print '0.' to StdOut TRAP 0,Fputs,StdOut FIX z,0,z % convert float z to integer // print mantissa 0H GREG #3030303030303030 STO 0B,BUF STO 0B,BUF+8 % store print mask in buffer LDA$255,BUF+16	% points after LSD
% repeat
2H	SUB	$255,$255,1	%   move pointer down
DIV	z,z,10		%   (q,r) = divmod z 10
GET	t,rR		%   get remainder
INCL	t,'0'		%   convert to ascii digit
STBU	t,$255,0 % store digit in buffer BNZ z,2B % until q == 0 TRAP 0,Fputs,StdOut % print mantissa Exp BYTE 'e',#00 LDA$255,Exp	% print 'exponent' indicator
TRAP	0,Fputs,StdOut
// print exponent
0H	GREG	#3030300000000000
STO	0B,BUF
LDA	$255,BUF+2 % store print mask in buffer CMP$73,$75,0 % if exp neg then place - in buffer BNN$73,2F
ExpSign	BYTE	'-'
LDA	$255,ExpSign TRAP 0,Fputs,StdOut NEG$75,$75 % make exp positive 2H LDA$255,BUF+3	% points after LSD
% repeat
3H	SUB	$255,$255,1	%   move pointer down
DIV	$75,$75,10	%   (q,r) = divmod exp 10
GET	t,rR
INCL	t,'0'
STBU	t,$255,0 % store exp. digit in buffer BNZ$75,3B		% until q == 0
TRAP	0,Fputs,StdOut	% print exponent
LDA	$255,NewLn TRAP 0,Fputs,StdOut % do a NL GO$127,$127,0 % return i IS$5 ;iu IS $6 Main SET iu,1000 SETH y,#3ff0 y = 1.0 SETH z,#0000 z = 0.0 SET i,1 for (i=1;i<=1000; i++ ) { 1H FLOT x,i x = int i FMUL x,x,x x = x^2 FDIV x,y,x x = 1 / x FADD z,z,x s = s + x ADD i,i,1 CMP t,i,iu PBNP t,1B } z = sum GO$127,prtFlt  print sum --> StdOut
TRAP	0,Halt,0

Output:

~/MIX/MMIX/Rosetta> mmix sumseries
0.1643934566681562e1

## Modula-2

MODULE SeriesSum;
FROM InOut IMPORT WriteLn;
FROM RealInOut IMPORT WriteReal;

TYPE RealFunc = PROCEDURE (REAL): REAL;

PROCEDURE seriesSum(k, n: CARDINAL; f: RealFunc): REAL;
VAR total: REAL;
i: CARDINAL;
BEGIN
total := 0.0;
FOR i := k TO n DO
total := total + f(FLOAT(i));
END;
END seriesSum;

PROCEDURE oneOverKSquared(k: REAL): REAL;
BEGIN
RETURN 1.0 / (k * k);
END oneOverKSquared;

BEGIN
WriteReal(seriesSum(1, 1000, oneOverKSquared), 10);
WriteLn;
END SeriesSum.
Output:
1.6439E+00

## Modula-3

Modula-3 uses D0 after a floating point number as a literal for LONGREAL.

MODULE Sum EXPORTS Main;

IMPORT IO, Fmt, Math;

VAR sum: LONGREAL := 0.0D0;

PROCEDURE F(x: LONGREAL): LONGREAL =
BEGIN
RETURN 1.0D0 / Math.pow(x, 2.0D0);
END F;

BEGIN
FOR i := 1 TO 1000 DO
sum := sum + F(FLOAT(i, LONGREAL));
END;
IO.Put("Sum of F(x) from 1 to 1000 is ");
IO.Put(Fmt.LongReal(sum));
IO.Put("\n");
END Sum.

Output:

Sum of F(x) from 1 to 1000 is 1.6439345666815612

## MUMPS

SOAS(N)
NEW SUM,I SET SUM=0
FOR I=1:1:N DO
.SET SUM=SUM+(1/((I*I)))
QUIT SUM

This is an extrinsic function so the usage is:

USER>SET X=SOAS^ROSETTA(1000) WRITE X
1.643934566681559806

## NewLISP

(let (s 0)
(for (i 1 1000)
(inc s (div 1 (* i i))))
(println s))

## Nial

|sum (1 / power (count 1000) 2)
=1.64393

## Nim

var s = 0.0
for n in 1..1000: s += 1 / (n * n)
echo s
Output:
1.643934566681561

## Oberon-2

Translation of: Modula-2
MODULE SS;

IMPORT Out;

TYPE
RealFunc = PROCEDURE(r:REAL):REAL;

PROCEDURE SeriesSum(k,n:LONGINT;f:RealFunc):REAL;
VAR
total:REAL;
i:LONGINT;
BEGIN
total := 0.0;
FOR i := k TO n DO total := total + f(i) END;
END SeriesSum;

PROCEDURE OneOverKSquared(k:REAL):REAL;
BEGIN RETURN 1.0 / (k * k)
END OneOverKSquared;

BEGIN
Out.Real(SeriesSum(1,1000,OneOverKSquared),10);
Out.Ln;
END SS.
Output:
1.64393E+00

## Objeck

bundle Default {
class SumSeries {
function : Main(args : String[]) ~ Nil {
DoSumSeries();
}

function : native : DoSumSeries() ~ Nil {
start := 1;
end := 1000;

sum := 0.0;

for(x : Float := start; x <= end; x += 1;) {
sum += f(x);
};

IO.Console->GetInstance()->Print("Sum of f(x) from ")->Print(start)->Print(" to ")->Print(end)->Print(" is ")->PrintLine(sum);
}

function : native : f(x : Float) ~ Float {
return 1.0 / (x * x);
}
}
}

## OCaml

let sum a b fn =
let result = ref 0. in
for i = a to b do
result := !result +. fn i
done;
!result
# sum 1 1000 (fun x -> 1. /. (float x ** 2.))
- : float = 1.64393456668156124

or in a functional programming style:

let sum a b fn =
let rec aux i r =
if i > b then r
else aux (succ i) (r +. fn i)
in
aux a 0.
;;

Simple recursive solution:

let rec sum n = if n < 1 then 0.0 else sum (n-1) +. 1.0 /. float (n*n)
in sum 1000

## Octave

Given a vector, the sum of all its elements is simply sum(vector); a range can be generated through the range notation: sum(1:1000) computes the sum of all numbers from 1 to 1000. To compute the requested series, we can simply write:

sum(1 ./ [1:1000] .^ 2)

## Oforth

: sumSerie(s, n)   0 n seq apply(#[ s perform + ]) ;

Usage :

#[ sq inv ] 1000 sumSerie println
Output:
1.64393456668156

## OpenEdge/Progress

Conventionally like elsewhere:

def var dcResult as decimal no-undo.
def var n as int no-undo.

do n = 1 to 1000 :
dcResult = dcResult + 1 / (n * n)  .
end.

display dcResult .

or like this:

def var n as int no-undo.

repeat n = 1 to 1000 :
accumulate 1 / (n * n) (total).
end.

display ( accum total 1 / (n * n) )  .

## Oz

With higher-order functions:

declare
fun {SumSeries S N}
{FoldL {Map {List.number 1 N 1} S}
Number.'+' 0.}
end

fun {S X}
1. / {Int.toFloat X*X}
end
in
{Show {SumSeries S 1000}}

Iterative:

fun {SumSeries S N}
R = {NewCell 0.}
in
for I in 1..N do
R := @R + {S I}
end
@R
end

## Panda

sum{{1.0.divide(1..1000.sqr)}}

Output:

1.6439345666815615

## PARI/GP

Exact rational solution:

sum(n=1,1000,1/n^2)

Real number solution (accurate to ${\displaystyle 3\cdot 10^{-36}}$  at standard precision):

sum(n=1,1000,1./n^2)

Approximate solution (accurate to ${\displaystyle 9\cdot 10^{-11}}$  at standard precision):

zeta(2)-intnum(x=1000.5,[1],1/x^2)

or

zeta(2)-1/1000.5

## Pascal

Program SumSeries;
type
tOutput = double;//extended;
tmyFunc = function(number: LongInt): tOutput;

function f(number: LongInt): tOutput;
begin
f := 1/sqr(tOutput(number));
end;

function Sum(from,upto: LongInt;func:tmyFunc):tOutput;
var
res: tOutput;
begin
res := 0.0;
//  for from:= from to upto do res := res + f(from);
for upTo := upto downto from do res := res + f(upTo);
Sum := res;
end;

BEGIN
writeln('The sum of 1/x^2 from 1 to 1000 is: ', Sum(1,1000,@f));
writeln('Whereas pi^2/6 is:                  ', pi*pi/6:10:8);
end.

Output

different version of type and calculation
extended low to high 1.64393456668155980263E+0000
extended high to low 1.64393456668155980307E+0000
double low to high 1.6439345666815612E+000
double high to low 1.6439345666815597E+000
Out:
The sum of 1/x^2 from 1 to 1000 is:  1.6439345666815612E+000
Whereas pi^2/6 is:                  1.64493407

## PascalABC.NET

##
(1..1000).Sum(k -> 1/k**2).Println
Output:
1.64393456668156

## Perl

my $sum = 0;$sum += 1 / $_ ** 2 foreach 1..1000; print "$sum\n";

or

use List::Util qw(reduce);
$sum = reduce {$a + 1 / $b ** 2 } 0, 1..1000; print "$sum\n";

An other way of doing it is to define the series as a closure:

my $S = do { my ($sum, $k); sub {$sum += 1/++$k**2 } }; my @S = map &$S, 1 .. 1000;
print $S[-1]; ## Phix function sumto(atom n) atom res = 0 for i=1 to n do res += 1/(i*i) end for return res end function ?sumto(1000) Output: 1.643934567 ## PHP <?php /** * @author Elad Yosifon */ /** * @param int$n
* @param int $k * @return float|int */ function sum_of_a_series($n,$k) {$sum_of_a_series = 0;
for($i=$k;$i<=$n;$i++) {$sum_of_a_series += (1/($i*$i));
}
return $sum_of_a_series; } echo sum_of_a_series(1000,1); Output: 1.6439345666816 ## Picat ### List comprehension s(N) = sum([1.0/K**2 : K in 1..N]). ### Iterative s2(N) = Sum => K = 1, Sum1 = 0, while(K <= N) Sum1 := Sum1 + 1/K**2, K := K + 1 end, Sum = Sum1. ### Test go => % List comprehension test(s,1000), nl, % Iterative test(s2,1000), nl. test(Fun,N) => println([fun=Fun,n=N]), Pi2_6 = math.pi**2/6, println(Pi2_6='math.pi**2/6'), nl, foreach(I in 1..6) S = apply(Fun,10**I), printf("%f (diff: %w)\n", S,Pi2_6-S) end, nl. Output: [fun = s,n = 1000] 1.644934066848226 = math.pi**2/6 1.549768 (diff: 0.095166335681686) 1.634984 (diff: 0.009950166663334) 1.643935 (diff: 0.000999500166665) 1.644834 (diff: 0.000099995000161) 1.644924 (diff: 0.000009999949984) 1.644933 (diff: 0.000000999999456) [fun = s2,n = 1000] 1.644934066848226 = math.pi**2/6 1.549768 (diff: 0.095166335681686) 1.634984 (diff: 0.009950166663334) 1.643935 (diff: 0.000999500166665) 1.644834 (diff: 0.000099995000161) 1.644924 (diff: 0.000009999949984) 1.644933 (diff: 0.000000999999456) ## PicoLisp (scl 9) # Calculate with 9 digits precision (let S 0 (for I 1000 (inc 'S (*/ 1.0 (* I I))) ) (prinl (round S 6)) ) # Round result to 6 digits Output: 1.643935 ## Pike array(int) x = enumerate(1000,1,1); +(@(1.0/pow(x[*],2)[*])); Result: 1.64393 ## PL/I /* sum the first 1000 terms of the series 1/n**2. */ s = 0; do i = 1000 to 1 by -1; s = s + 1/float(i**2); end; put skip list (s); Output: 1.64393456668155980E+0000 ## Pop11 lvars s = 0, j; for j from 1 to 1000 do s + 1.0/(j*j) -> s; endfor; s => ## PostScript /aproxriemann{ /x exch def /i 1 def /sum 0 def x{ /sum sum i -2 exp add def /i i 1 add def }repeat sum == }def 1000 aproxriemann Output: 1.64393485 Library: initlib % using map [1 1000] 1 range {dup * 1 exch div} map 0 {+} fold % just using fold [1 1000] 1 range 0 {dup * 1 exch div +} fold ## Potion sum = 0.0 1 to 1000 (i): sum = sum + 1.0 / (i * i). sum print ## PowerShell$x = 1..1000 
| ForEach-Object { 1 / ($_ *$_) }
| Measure-Object -Sum
Write-Host Sum = $x.Sum ## Prolog Works with SWI-Prolog. sum(S) :- findall(L, (between(1,1000,N),L is 1/N^2), Ls), sumlist(Ls, S). Ouptput : ?- sum(S). S = 1.643934566681562. ## PureBasic Define i, sum.d For i=1 To 1000 sum+1.0/(i*i) Next i Debug sum Answer = 1.6439345666815615 ## Python print ( sum(1.0 / (x * x) for x in range(1, 1001)) ) Or, as a generalised map, or fold / reduction – (see Catamorphism#Python): '''The sum of a series''' from functools import reduce # seriesSumA :: (a -> b) -> [a] -> b def seriesSumA(f): '''The sum of the map of f over xs.''' return lambda xs: sum(map(f, xs)) # seriesSumB :: (a -> b) -> [a] -> b def seriesSumB(f): '''Folding acc + f(x) over xs where acc begins at 0.''' return lambda xs: reduce( lambda a, x: a + f(x), xs, 0 ) # TEST ---------------------------------------------------- # main:: IO () def main(): '''Summing 1/x^2 over x = 1..1000''' def f(x): return 1 / (x * x) print( fTable( __doc__ + ':\n' + '(1/x^2 over x = 1..1000)' )(lambda f: '\tby ' + f.__name__)(str)( lambda g: g(f)(enumFromTo(1)(1000)) )([seriesSumA, seriesSumB]) ) # GENERIC ------------------------------------------------- # compose (<<<) :: (b -> c) -> (a -> b) -> a -> c def compose(g): '''Right to left function composition.''' return lambda f: lambda x: g(f(x)) # enumFromTo :: (Int, Int) -> [Int] def enumFromTo(m): '''Integer enumeration from m to n.''' return lambda n: list(range(m, 1 + n)) # fTable :: String -> (a -> String) -> # (b -> String) -> # (a -> b) -> [a] -> String def fTable(s): '''Heading -> x display function -> fx display function -> f -> value list -> tabular string.''' def go(xShow, fxShow, f, xs): w = max(map(compose(len)(xShow), xs)) return s + '\n' + '\n'.join([ xShow(x).rjust(w, ' ') + ( ' -> ' ) + fxShow(f(x)) for x in xs ]) return lambda xShow: lambda fxShow: ( lambda f: lambda xs: go( xShow, fxShow, f, xs ) ) # MAIN --- if __name__ == '__main__': main() Output: The sum of a series: (1/x^2 over x = 1..1000) by seriesSumA -> 1.6439345666815615 by seriesSumB -> 1.6439345666815615 ## Q sn:{sum xexp[;-2] 1+til x} sn 1000 Output: 1.643935 ## Quackery Using the Quackery bignum rational arithmetic suite bigrat.qky. [$ "bigrat.qky" loadfile ] now!

[ 0 n->v rot times
[ i^ 1+ 2 ** n->v 1/v v+ ] ] is sots ( n --> n/d )

1000 sots
2dup
proper 1000000 round improper

say "Sum of the series to n=1000."
cr cr
say "As a proper fraction, best approximation where the denominator does not exceed 1 million."
cr cr
proper$echo$ say " (Correct to ten places after the decimal point.)"
cr cr
say "As a decimal fraction, first 1000 places after the decimal point."
cr cr
1000 point$echo$
Output:
Sum of the series to n=1000.

As a proper fraction, best approximation where the denominator does not exceed 1 million.

1 120258/186755 (Correct to ten places after the decimal point.)

As a decimal fraction, first 1000 places after the decimal point.

1.6439345666815598031390580238222155896521034464936853167172372054281147052136371544864376381235947140840247689830052307986940209330560586814364561437341082161835849587934021025978122814760355990612544129425222414004531893441493046096060608253065583656711834617047405403932309749347134167799683552617330444813936406879861764067575322580319473862296485681925322084905899406792924876019403018468725753572490400061711335030331913299036845451416705045304303525919036749150124063804931627056349457943068021121600349225249063311667960633996823281725263770542297902063202752003109461373037518723003263479387388393217302120377472207068721127250339809048861023369090772476245864265860225860011245643262424159227627089164279360808513966752516418684047190163638741163457263381145491031118582607024223083056005537196735365330300185181967964028738217100545990163108755787441026888189509196651819302024386462242896954169347538400396493562377033255763634275476803474905179930119321187665211349199562778792639603861646

## R

print( sum( 1/seq(1000)^2 ) )

## Racket

A solution using Typed Racket:

#lang typed/racket

(: S : Natural -> Real)
(define (S n)
(for/sum: : Real ([k : Natural (in-range 1 (+ n 1))])
(/ 1.0 (* k k))))

## Raku

(formerly Perl 6)

Works with: rakudo version 2016.04

In general, the $nth partial sum of a series whose terms are given by a unary function &f is [+] map &f, 1 ..$n

So what's needed in this case is

say [+] map { 1 / $^n**2 }, 1 .. 1000; Or, using the "hyper" metaoperator to vectorize, we can use a more "point free" style while keeping traditional precedence: say [+] 1 «/« (1..1000) »**» 2; Or we can use the X "cross" metaoperator, which is convenient even if one side or the other is a scalar. In this case, we demonstrate a scalar on either side: say [+] 1 X/ (1..1000 X** 2); Note that cross ops are parsed as list infix precedence rather than using the precedence of the base op as hypers do. Hence the difference in parenthesization. With list comprehensions, you can write: say [+] (1 /$_**2 for 1..1000);

That's fine for a single result, but if you're going to be evaluating the sequence multiple times, you don't want to be recalculating the sum each time, so it's more efficient to define the sequence as a constant to let the run-time automatically cache those values already calculated. In a lazy language like Raku, it's generally considered a stronger abstraction to write the correct infinite sequence, and then take the part of it you're interested in. Here we define an infinite sequence of partial sums (by adding a backslash into the reduction to make it look "triangular"), then take the 1000th term of that:

constant @x = [\+] 0, { 1 / ++(state $n) ** 2 } ... *; say @x[1000]; # prints 1.64393456668156 Note that infinite constant sequences can be lazily generated in Raku, or this wouldn't work so well... A cleaner style is to combine these approaches with a more FP look: constant ζish = [\+] map -> \𝑖 { 1 / 𝑖**2 }, 1..*; say ζish[1000]; Perhaps the cleanest way is to just define the zeta function and evaluate it for s=2, possibly using memoization: use experimental :cached; sub ζ($s) is cached { [\+] 1..* X** -$s } say ζ(2)[1000]; Notice how the thus-defined zeta function returns a lazy list of approximated values, which is arguably the closest we can get from the mathematical definition. ## Raven 0 1 1000 1 range each 1.0 swap dup * / + "%g\n" print Output: 1.64393 Raven uses a 32 bit float, so precision limits the accuracy of the result for large iterations. ## Red Red [] s: 0 repeat n 1000 [ s: 1.0 / n ** 2 + s ] print s ## REXX ### sums specific terms /*REXX program sums the first N terms of 1/(k**2), k=1 ──► N. */ parse arg N D . /*obtain optional arguments from the CL*/ if N=='' | N=="," then N=1000 /*Not specified? Then use the default.*/ if D=='' | D=="," then D= 60 /* " " " " " " */ numeric digits D /*use D digits (9 is the REXX default).*/$=0                                              /*initialize the sum to zero.          */
do k=1  for N                          /* [↓]  compute for   N   terms.       */
$=$  +  1/k**2                         /*add a squared reciprocal to the sum. */
end   /*k*/

say 'The sum of'     N     "terms is:"    /*stick a fork in it, we're all done. */ output when using the default input: The sum of 1000 terms is: 1.64393456668155980313905802382221558965210344649368531671713 ### sums with running total This REXX version shows the running total for every 10th term. /*REXX program sums the first N terms o f 1/(k**2), k=1 ──► N. */ parse arg N D . /*obtain optional arguments from the CL*/ if N=='' | N=="," then N=1000 /*Not specified? Then use the default.*/ if D=='' | D=="," then D= 60 /* " " " " " " */ numeric digits D /*use D digits (9 is the REXX default).*/ w=length(N) /*W is used for aligning the output. */=0                                              /*initialize the sum to zero.          */
do k=1  for N                              /* [↓]  compute for   N   terms.       */
$=$  +  1/k**2                             /*add a squared reciprocal to the sum. */
parse var k s 2 m '' -1 e                  /*obtain the start and end decimal digs*/
if e\==0  then iterate                     /*does K  end  with the dec digit  0 ? */
if s\==1  then iterate                     /*  "  " start   "   "   "    "    1 ? */
if m\=0   then iterate                     /*  "  " middle  contain any non-zero ?*/
if k==N   then iterate                     /*  "  " equal N, then skip running sum*/
say  'The sum of'   right(k,w)     "terms is:"  $/*display a running sum.*/ end /*k*/ say /*a blank line for sep. */ say 'The sum of' right(k-1,w) "terms is:"$         /*display the final sum.*/
/*stick a fork in it,  we're all done. */

output   when using the input of:   1000000000

The sum of         10 terms is: 1.54976773116654069035021415973796926177878558830939783320736
The sum of        100 terms is: 1.63498390018489286507716949818032376668332170003126381385307
The sum of       1000 terms is: 1.64393456668155980313905802382221558965210344649368531671713
The sum of      10000 terms is: 1.64483407184805976980608183331031090353799751949684175308996
The sum of     100000 terms is: 1.64492406689822626980574850331269185564752132981156034248806
The sum of    1000000 terms is: 1.64493306684872643630574849997939185588561654406394129491321
The sum of   10000000 terms is: 1.64493396684823143647224849997935852288561656787346272343397
The sum of  100000000 terms is: 1.64493405684822648647241499997935852255228656787346510441026
The sum of 1000000000 terms is: 1.64493406584822643697241516647935852255228323457346510444171

output   from a calculator computing   ${\displaystyle \pi }$ 2/6,   (using 60 digits)   showing the correct number (nine) of decimal digits   [the superscripting of the digits was edited after-the-fact]:

1.64493406684822643647241516664602518921894990120679843773556

### sums with running significance

This is a technique to show a   running significance   (based on the previous calculation).

If the   old   REXX variable would be set to   1.64   (instead of   1), the first noise digits could be bypassed to make the display cleaner.

/*REXX program sums the first    N    terms of     1/(k**2),          k=1 ──►  N.       */
parse arg N D .                                  /*obtain optional arguments from the CL*/
if N=='' | N==","  then N=1000                   /*Not specified?  Then use the default.*/
if D=='' | D==","  then D=  60                   /* "      "         "   "   "     "    */
numeric digits D                                 /*use D digits (9 is the REXX default).*/
w=length(N)                                      /*W   is used for aligning the output. */
$=0 /*initialize the sum to zero. */ old=1 /*the new sum to compared to the old. */ p=0 /*significant decimal precision so far.*/ do k=1 for N /* [↓] compute for N terms. */$=$+ 1/k**2 /*add a squared reciprocal to the sum. */ c=compare($,old)                            /*see how we're doing with precision.  */
if c>p  then do                             /*Got another significant decimal dig? */
say 'The significant sum of'  right(k,w)      "terms is:"      left($,c) p=c /*use the new significant precision. */ end /* [↑] display significant part of sum*/ old=$                                       /*use "old" sum for the next compare.  */
end   /*k*/
say                                              /*display blank line for the separator.*/
say 'The sum of'   right(N,w)    "terms is:"     /*display the  sum's  preamble line.   */
say $/*stick a fork in it, we're all done. */ output when using the input of (one billion [limit], and one hundred decimal digits): 1000000000 100 The significant sum of 3 terms is: 1.3 The significant sum of 5 terms is: 1.46 The significant sum of 14 terms is: 1.575 The significant sum of 34 terms is: 1.6159 The significant sum of 110 terms is: 1.63588 The significant sum of 328 terms is: 1.641889 The significant sum of 1024 terms is: 1.6439579 The significant sum of 3207 terms is: 1.64462229 The significant sum of 10043 terms is: 1.644834499 The significant sum of 31782 terms is: 1.6449026029 The significant sum of 100314 terms is: 1.64492409819 The significant sum of 316728 terms is: 1.644930909569 The significant sum of 1000853 terms is: 1.6449330677009 The significant sum of 3163463 terms is: 1.64493375073899 The significant sum of 10001199 terms is: 1.644933966860219 The significant sum of 31627592 terms is: 1.6449340352302649 The significant sum of 100009299 terms is: 1.64493405684915629 The significant sum of 316233759 terms is: 1.644934063686008709 The sum of 1000000000 terms is: 1.644934065848226436972415166479358522552283234573465104402224896012864613260343731009819376810240620 One can see a pattern in the number of significant digits computed based on the number of terms used. (See a discussion in the talk section.) ## Ring sum = 0 for i =1 to 1000 sum = sum + 1 /(pow(i,2)) next decimals(8) see sum ## RLaB >> sum( (1 ./ [1:1000]) .^ 2 ) - const.pi^2/6 -0.000999500167 ## RPL ≪ 0 1 ROT FOR k SQ INV + NEXT ≫ '∑INV2' STO 1000 ∑INV2 The emulator immediately returns 1: 1.64393456668 A basic HP-28S calculator returns after 27.5 seconds 1: 1.64393456674 Works with: HP version 49 'k' 1 1000 '1/SQ(k)' ∑ returns in 2 minutes 27 seconds, with exact mode set: 1: 83545938483149689478187854264854884386044454314086472930763839512603803291207881839588904977469387999844962675327115010933903589145654299730231109091124308462732153297321867661093162618281746011828755017021645889046777854795025297006943669294330752479399654716368801794529682603741344724733173765262964463970763934463926259796895140901128384286333311745462863716753134735154188954742414035836608258393970996630553795415075904205673610359458498106833291961256452756993199997231825920203667952667546787052535763624910912251107083702817265087341966845358732584971361645348091123849687614886682117125784781422103460192439394780707024963279033532646857677925648889105430050030795563141941157379481719403833258405980463950499887302926152552848089894630843538497552630691676216896740675701385847032173192623833881016332493844186817408141003602396236858699094240207812766449 / 50820720104325812617835292273000760481839790754374852703215456050992581046448162621598030244504097240825920773913981926305208272518886258627010933716354037062979680120674828102224650586465553482032614190502746121717248161892239954030493982549422690846180552358769564169076876408783086920322038142618269982747137757706040198826719424371333781947889528085329853597116893889786983109597085041878513917342099206896166585859839289193299599163669641323895022932959750057616390808553697984192067774252834860398458100840611325353202165675189472559524948330224159123505567527375848194800452556940453530457590024173749704941834382709198515664897344438584947842793131829050180589581507273988682409028088248800576590497216884808783192565859896957125449502802395453976401743504938336291933628859306247684023233969172475385327442707968328512729836445886537101453118476390400000000 ## Ruby puts (1..1000).sum{ |x| 1r / x ** 2 }.to_f Output: 1.64393456668156 ## Run BASIC for i =1 to 1000 sum = sum + 1 /( i^2) next i print sum ## Rust const LOWER: i32 = 1; const UPPER: i32 = 1000; // Because the rule for our series is simply adding one, the number of terms are the number of // digits between LOWER and UPPER const NUMBER_OF_TERMS: i32 = (UPPER + 1) - LOWER; fn main() { // Formulaic method println!("{}", (NUMBER_OF_TERMS * (LOWER + UPPER)) / 2); // Naive method println!("{}", (LOWER..UPPER + 1).fold(0, |sum, x| sum + x)); } ## SAS data _null_; s=0; do n=1 to 1000; s+1/n**2; /* s+x is synonym of s=s+x */ end; e=s-constant('pi')**2/6; put s e; run; ## Scala scala> 1 to 1000 map (x => 1.0 / (x * x)) sum res30: Double = 1.6439345666815615 ## Scheme (define (sum a b fn) (do ((i a (+ i 1)) (result 0 (+ result (fn i)))) ((> i b) result))) (sum 1 1000 (lambda (x) (/ 1 (* x x)))) ; fraction (exact->inexact (sum 1 1000 (lambda (x) (/ 1 (* x x))))) ; decimal More idiomatic way (or so they say) by tail recursion: (define (invsq f to) (let loop ((f f) (s 0)) (if (> f to) s (loop (+ 1 f) (+ s (/ 1 f f)))))) ;; whether you get a rational or a float depends on implementation (invsq 1 1000) ; 835459384831...766449/50820...90400000000 (exact->inexact (invsq 1 1000)) ; 1.64393456668156 ## Seed7$ include "seed7_05.s7i";
include "float.s7i";

const func float: invsqr (in float: n) is
return 1.0 / n**2;

const proc: main is func
local
var integer: i is 0;
var float: sum is 0.0;
begin
for i range 1 to 1000 do
sum +:= invsqr(flt(i));
end for;
end func;

## SETL

print( +/[1/k**2 : k in [1..1000]] );
Output:
1.64393456668156

## Sidef

say sum(1..1000, {|n| 1 / n**2 })

Alternatively, using the reduce{} method:

say (1..1000 -> reduce { |a,b| a + (1 / b**2) })
Output:
1.64393456668155980313905802382221558965210344649369

## Slate

Manually coerce it to a float, otherwise you will get an exact (and slow) answer:

((1 to: 1000) reduce: [|:x :y | x + (y squared reciprocal as: Float)]).

## Smalltalk

( (1 to: 1000) fold: [:sum :aNumber |
sum + (aNumber squared reciprocal) ] ) asFloat displayNl.

## SparForte

As a structured script.

#!/usr/local/bin/spar
pragma annotate( summary, "sumseries" )
@( description, "Compute the nth term of a series, i.e. the " )
@( description, "sum of the n first terms of the " )
@( description, "corresponding sequence.  For this task " )
@( description, "repeat 1000 times. " )
@( see_also, "http://rosettacode.org/wiki/Sum_of_a_series" )
@( author, "Ken O. Burtch" );

pragma restriction( no_external_commands );

procedure sumseries is

function inverse_square( x : long_float ) return long_float is
begin
return 1/x**2;
end inverse_square;

total : long_float := 0.0;
max_param : constant natural := 1000;

begin
for i in 1..max_param loop
total := @ + inverse_square( i );
end loop;

put( "Sum of F(x) from 1 to" )
@( max_param )
@( " is" )
@( total );
new_line;
end sumseries;

## SQL

create table t1 (n real);
-- this is postgresql specific, fill the table
insert into t1 (select generate_series(1,1000)::real);
with tt as (
select 1/(n*n) as recip from t1
) select sum(recip) from tt;

Result of select (with locale DE):

sum
------------------
1.64393456668156
(1 Zeile)

## Stata

function series(n) {
return(sum((n..1):^-2))
}

series(1000)-pi()^2/6
-.0009995002

## Swift

func sumSeries(var n: Int) -> Double {
var ret: Double = 0

for i in 1...n {
ret += (1 / pow(Double(i), 2))
}

return ret
}

output: 1.64393456668156
Swift also allows extension to datatypes.  Here's similar code using an extension to Int.

extension Int {
func SumSeries() -> Double {
var ret: Double = 0

for i in 1...self {
ret += (1 / pow(Double(i), 2))
}

return ret
}
}

var x: Int = 1000
var y: Double

y = x.sumSeries()   /* y = 1.64393456668156 */

Swift also allows you to do this:

y = 1000.sumSeries()

## Tcl

### Using Expansion Operator and mathop

Works with: Tcl version 8.5
package require Tcl 8.5
proc lsum_series {l} {+ {*}[lmap n $l {/ [**$n 2]}]} ;# an expr would be clearer, but this is a demonstration of mathop

# using range function defined below
lsum_series [range 1 1001] ;# ==> 1.6439345666815615

### Using Loop

Works with: Tcl version 8.5
package require Tcl 8.5

proc partial_sum {func - start - stop} {
for {set x $start; set sum 0} {$x <= $stop} {incr x} { set sum [expr {$sum + [apply $func$x]}]
}
return $sum } set S {x {expr {1.0 /$x**2}}}

partial_sum $S from 1 to 1000 ;# => 1.6439345666815615 ### Using tcllib Library: Tcllib (Package: struct::list) package require Tcl 8.5 package require struct::list proc sum_of {lambda nums} { struct::list fold [struct::list map$nums [list apply $lambda]] 0 ::tcl::mathop::+ } set S {x {expr {1.0 /$x**2}}}

sum_of $S [range 1 1001] ;# ==> 1.6439345666815615 The helper range procedure is: # a range command akin to Python's proc range args { foreach {start stop step} [switch -exact -- [llength$args] {
1 {concat 0 $args 1} 2 {concat$args 1}
3 {concat   $args } default {error {wrong # of args: should be "range ?start? stop ?step?"}} }] break if {$step == 0} {error "cannot create a range when step == 0"}
set range [list]
while {$step > 0 ?$start < $stop :$stop < $start} { lappend range$start
incr start $step } return$range
}

## TI-83 BASIC

### TI-84 Version

Translation of: TI-89 BASIC
Works with: TI-83 BASIC version TI-84Plus 2.55MP
∑(1/X²,X,1,1000)
Output:
1.643934567

### TI-83 Version

The TI-83 does not have the new summation notation, and caps lists at 999 entries.

sum(seq(1/X²,X,1,999))
Output:
1.643933567

## TI-89 BASIC

∑(1/x^2,x,1,1000)

## TXR

Reduce with + operator over a lazily generated list.

Variant A1: limit the list generation inside the gen operator.

txr -p '[reduce-left + (let ((i 0)) (gen (< i 1000) (/ 1.0 (* (inc i) i)))) 0]'
1.64393456668156

Variant A2: generate infinite list, but take only the first 1000 items using [list-expr 0..999].

txr -p '[reduce-left + [(let ((i 0)) (gen t (/ 1.0 (* (inc i) i)))) 0..999] 0]'
1.64393456668156

Variant B: generate lazy integer range, and pump it through a series of function with the help of the chain functional combinator and the op partial evaluation/binding operator.

txr -p '[[chain range (op mapcar (op / 1.0 (* @1 @1))) (op reduce-left + @1 0)] 1 1000]'
1.64393456668156

Variant C: unravel the chain in Variant B using straightforward nesting.

txr -p '[reduce-left + (mapcar (op / 1.0 (* @1 @1)) (range 1 1000)) 0]'
1.64393456668156

Variant D: bring Variant B's inverse square calculation into the fold, eliminating mapcar. Final answer.

txr -p '[reduce-left (op + @1 (/ 1.0 (* @2 @2))) (range 1 1000) 0]'
1.64393456668156

See Icon.

## UnixPipes

term() {
b=$1;res=$2
echo "scale=5;1/($res*$res)+$b" | bc } sum() { (read B; res=$1;
test -n "$B" && (term$B $res) || (term 0$res))
}

fold() {
func=$1 (while read a ; do fold$func | $func$a
done)
}

(echo 3; echo 1; echo 4) | fold sum

## Ursala

The expression plus:-0. represents a function returning the sum of any given list of floating point numbers, or zero if it's empty, using the built in reduction operator, :-, and the binary addition function, plus. The rest the expression constructs the series by inverting the square of each number in the list from 1 to 1000.

#import flo
#import nat

#cast %e

total = plus:-0 div/*1. sqr* float*t iota 1001

output:

1.643935e+00

## Vala

public static void main(){
int i, start = 1, end = 1000;
double sum = 0.0;

for(i = start; i<= end; i++)
sum += (1 / (double)(i * i));

stdout.printf("%s\n", sum.to_string());
}

Output:

1.6439345666815615

## VBA

Private Function sumto(n As Integer) As Double
Dim res As Double
For i = 1 To n
res = res + 1 / i ^ 2
Next i
sumto = res
End Function
Public Sub main()
Debug.Print sumto(1000)
End Sub
Output:
1,64393456668156

## VBScript

' Sum of a series
for i=1 to 1000
s=s+1/i^2
next
wscript.echo s
Output:
1.64393456668156

## Visual Basic .NET

Translation of: VBScript
Works with: Visual Basic .NET version 2013
' Sum of a series
Sub SumOfaSeries()
Dim s As Double
s = 0
For i = 1 To 1000
s = s + 1 / i ^ 2
Next 'i
Console.WriteLine(s)
End Sub
Output:
1.64393456668156

## Verilog

module main;
integer i;
real sum;

initial begin
sum = 0.0;
for(i = 1; i <= 1000; i=i+1)  sum = sum + 1.0 / (i * i);
$display(sum); end endmodule 1.64393 ## V (Vlang) Translation of: go import math fn main(){ println('known:${math.pi*math.pi/6}')
mut sum := f64(0)
for i :=1e3; i >0; i-- {
sum += 1/(i*i)
}
println('computed: \$sum')
}

Output:

known:    1.6449340668482264
computed: 1.6439345666815597

## WDTE

let s => import 'stream';

s.range 1 1001
-> s.map (@ inner k => / 1 (* k k))
-> s.reduce 0 +
-- io.writeln io.stdout
;
Output:
1.643933567

## Wortel

@sum !*#~V1Sn @to 1000 ; returns 1.6439345666815615
@to 1000 ; generates a list of 1 to 1000 (inclusive)
#~V1Sn ; number expression which stands for: square push(1) swap divide
!* ; maps the number expression over the list
@sum ; sums the list

## Wren

var sumSeries = Fn.new { |n| (1..n).reduce(0) { |sum, i| sum + 1/(i*i) } }

System.print("s(1000) = %(sumSeries.call(1000))")
System.print("zeta(2) = %(Num.pi*Num.pi/6)")
Output:
s(1000) = 1.6439345666816
zeta(2) = 1.6449340668482

## XPL0

code CrLf=9;  code real RlOut=48;
int  X;  real S;
[S:= 0.0;
for X:= 1 to 1000 do S:= S + 1.0/float(X*X);
RlOut(0, S);  CrLf(0);
]

Output:

1.64393

## Yorick

(1./indgen(1:1000)^2)(sum)

## Zig

Works with: Zig version 0.11.0
const std = @import("std");

fn f(x: u64) f64 {
return 1 / @as(f64, @floatFromInt(x * x));
}

fn sum(comptime func: fn (u64) f64, n: u64) f64 {
var s: f64 = 0.0;
var i: u64 = n;

while (i != 0) : (i -= 1)
s += func(i);

return s;
}

pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("S_1000 = {d:.15}\n", .{sum(f, 1000)});
}
Output:
S_1000 = 1.643934566681560

## zkl

[1.0..1000].reduce(fcn(p,n){ p + 1.0/(n*n) },0.0)  //-->1.64394

## ZX Spectrum Basic

10 LET n=1000
20 LET s=0
30 FOR k=1 TO n
40 LET s=s+1/(k*k)
50 NEXT k
60 PRINT s
Output:
1.6439346

0 OK, 60:1