Sum of a series

Compute the nth term of a series, i.e. the sum of the n first terms of the corresponding sequence. Informally, it is also called the sum of the series, thus the title of this task.

For this task, use:

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

and compute it for n=1000.

This approximates the Riemann zeta function. The Basel problem solved this: $\zeta (2)={\pi ^{2} \over 6}$ .

ACL2

<lang lisp>(defun sum-x^-2 (max-x)

  (if (zp max-x)
      0
      (+ (/ (* max-x max-x))
         (sum-x^-2 (1- max-x)))))</lang>

ActionScript

<lang 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));</lang>

ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

<lang algol68>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,100);
 PROC f = (INT x)LONG REAL: LENG REAL(1) / LENG REAL(x)**2;
 print(("Sum of f(x) from", lwb OF range, " to ",upb OF range," is ", SHORTEN sum(f,range),".", new line))

)</lang> Output:

Sum of f(x) from         +1 to        +100 is +1.63498390018489e  +0.

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. <lang autohotkey>SetFormat, FloatFast, 0.15 While A_Index <= 1000

sum += 1/A_Index**2

MsgBox,% sum ;1.643934566681554</lang>

AWK

<lang awk>$ awk 'BEGIN{for(i=1;i<=1000;i++)s+=1/(i*i);print s}' 1.64393</lang>

BASIC

Works with: QuickBasic version 4.5

<lang qbasic>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)</lang>

BBC BASIC

<lang bbcbasic> FOR i% = 1 TO 1000

       sum += 1/i%^2
     NEXT
     PRINT sum</lang>

Brat

<lang brat>p 1.to(1000).reduce 0 { sum, x | sum + 1.0 / x ^ 2 } #Prints 1.6439345666816</lang>

C

<lang 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; }</lang>

C++

<lang cpp>#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 ) );

}</lang>

C#

<lang csharp>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();
   }

}</lang>

An alternative approach using Enumerable.Range() to generate the numbers.

<lang csharp>class Program {

   static void Main(string[] args)
   {
       double sum = Enumerable.Range(1, 1000).Sum(x => 1.0 / (x * x));

       Console.WriteLine(sum);
       Console.ReadLine();
   }

}</lang>

CLIPS

<lang 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)

)</lang>

Usage:

CLIPS> (partial-sum-S 1 1000)
1.64393456668156

Clojure

<lang clojure>(reduce + (map #(/ 1.0 % %) (range 1 1001)))</lang>

CoffeeScript

<lang CoffeeScript> console.log [1..1000].reduce((acc, x) -> acc + (1.0 / (x*x))) </lang>

Common Lisp

<lang lisp>(loop for x from 1 to 1000 summing (expt x -2))</lang>

D

More Procedural Style

<lang d>import std.stdio, std.traits;

ReturnType!TF series(TF)(TF func, int end, int start=1) pure nothrow {

   typeof(return) sum = 0;
   foreach (i; start .. end + 1)
       sum += func(i);
   return sum;

}

void main() {

   writeln("Sum: ", series((int n) => 1.0L / (n ^^ 2), 1_000));

}</lang>

Output:

Sum: 1.64393

More functional Style

Same output. <lang d>import std.stdio, std.algorithm, std.range;

auto series(alias F)(in int end, in int start=1) /*pure*/ {

   return iota(start, end + 1).map!F().reduce!q{a + b}();

}

void main() {

   writeln("Sum: ", series!q{1.0L / (a ^^ 2)}(1_000));

}</lang>

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
   M_Log.Lines.Add(FloatToStr(Sum_Of_A_Series(1,trunc(sqrt($7FFFFFFFFFFFFFFF-1)))));
 except
   M_Log.Lines.Add('Error');
 end;

end;

end.

</lang>

Pi^2/6 = 1.644934066_848226436472415166646

result = 1,644934066_51266

E

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

Erlang

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

Euphoria

Works with: Euphoria version 4.0.0

This is based on the BASIC example. <lang Euphoria> 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 ) )</lang>

Factor

<lang factor>1000 [1,b] [ >float sq recip ] map-sum</lang>

Fantom

Within 'fansh':

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

Forth

<lang forth>: sum ( fn start count -- fsum )

 0e
 bounds do
   i s>d d>f dup execute f+
 loop drop ;

noname ( x -- 1/x^2 ) fdup f* 1/f ; ( xt )

1 1000 sum f. \ 1.64393456668156 pi pi f* 6e f/ f. \ 1.64493406684823</lang>

Fortran

In ISO Fortran 90 and later, use SUM intrinsic: <lang fortran>real, dimension(1000) :: a = (/ (1.0/(i*i), i=1, 1000) /) real :: result

result = sum(a);</lang>

F#

The following function will do the task specified. <lang fsharp>let rec f (x : float) =

   match x with
       | 0. -> x
       | x -> (1. / (x * x)) + f (x - 1.)</lang>

In the interactive F# console, using the above gives: <lang fsharp>> f 1000. ;; val it : float = 1.643934567</lang> 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: <lang fsharp>#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</lang>

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

GAP

<lang gap># We will compute the sum exactly

Computing an approximation of a rationnal (giving a string)
Value is truncated toward zero

Approx := function(x, d) local neg, a, b, n, m, s; if x < 0 then x := -x; neg := true; else neg := false; fi; a := NumeratorRat(x); b := DenominatorRat(x); n := QuoInt(a, b); a := RemInt(a, b); m := 10^d; s := ""; if neg then Append(s, "-"); fi; Append(s, String(n)); n := Size(s) + 1; Append(s, String(m + QuoInt(a*m, b))); s[n] := '.'; return s; end;

a := Sum([1 .. 1000], n -> 1/n^2);; Approx(a, 10); "1.6439345666"

and pi^2/6 is 1.6449340668, truncated to ten digits</lang>

Go

<lang 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)

}</lang> Output:

known:    1.6449340668482264
computed: 1.6439345666815597

Groovy

Start with smallest terms first to minimize rounding error: <lang groovy>println ((1000..1).collect { x -> 1/(x*x) }.sum())</lang>

Output:

1.6439345654

Haskell

With a list comprehension: <lang haskell>sum [1 / x ^ 2 | x <- [1..1000]]</lang> With higher-order functions: <lang haskell>sum $ map (\x -> 1 / x ^ 2) [1..1000]</lang> In point-free style: <lang haskell>(sum . map (1/) . map (^2)) [1..1000]</lang>

HicEst

<lang hicest>REAL :: a(1000)

       a = 1 / $^2
       WRITE(ClipBoard, Format='F17.15') SUM(a) </lang>

Icon and Unicon

<lang icon>procedure main()

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

end</lang>

or

<lang icon>procedure main()

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

end</lang>

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: <lang icon>

  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 +:=

</lang>

IDL

<lang idl>print,total( 1/(1+findgen(1000))^2)</lang>

J

<lang 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</lang>

Java

<lang 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);
   }

}</lang>

JavaScript

<lang javascript>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</lang>

K

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

1.643935 </lang>

Liberty BASIC

<lang lb> for i =1 to 1000

 sum =sum +1 /( i^2)

next i

print sum

end </lang>

Logo

<lang 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</lang>

Lua

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

Lucid

<lang lucid>series = ssum asa n >= 1000

  where
        num = 1 fby num + 1;
        ssum = ssum + 1/(num * num)
  end;</lang>

Mathematica

This is the straightforward solution of the task: <lang mathematica>Sum[1/x^2, {x, 1, 1000}]</lang> However this returns a quotient of two huge integers (namely the exact sum); to get a floating point approximation, use N: <lang mathematica>N[Sum[1/x^2, {x, 1, 1000}]]</lang> or better: <lang mathematica>NSum[1/x^2, {x, 1, 1000}]</lang> 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: <lang mathematica>Sum[1./x^2, {x, 1, 1000}]</lang> Other ways include (exact, approximate,exact,approximate): <lang mathematica>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}]</lang>

MATLAB

Maxima

<lang 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</lang>

MAXScript

<lang maxscript>total = 0 for i in 1 to 1000 do (

   total += 1.0 / pow i 2

) print total</lang>

MMIX

<lang 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</lang> Output:

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

Modula-3

Modula-3 uses D0 after a floating point number as a literal for LONGREAL. <lang modula3>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.</lang> Output:

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

MUMPS

<lang MUMPS> SOAS(N)

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

</lang> This is an extrinsic function so the usage is:

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

Nial

<lang nial>|sum (1 / power (count 1000) 2) =1.64393</lang>

Objeck

<lang 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);
   }
 }

} </lang>

OCaml

<lang ocaml>let sum a b fn =

 let result = ref 0. in
 for i = a to b do
   result := !result +. fn i
 done;
 !result</lang>

# sum 1 1000 (fun x -> 1. /. (float x ** 2.))
- : float = 1.64393456668156124

or in a functional programming style: <lang ocaml>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.

</lang>

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:

OpenEdge/Progress

Conventionally like elsewhere:

<lang Progress (Openedge ABL)>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 .</lang>

or like this:

<lang Progress (Openedge ABL)>def var n as int no-undo.

repeat n = 1 to 1000 :

 accumulate 1 / (n * n) (total).

end.

display ( accum total 1 / (n * n) ) .</lang>

Oz

With higher-order functions: <lang oz>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}}</lang>

Iterative: <lang oz> fun {SumSeries S N}

    R = {NewCell 0.}
 in
    for I in 1..N do
       R := @R + {S I}
    end
    @R
 end</lang>

PARI/GP

Exact rational solution: <lang parigp>sum(n=1,1000,1/n^2)</lang>

Real number solution (accurate to $3\cdot 10^{-36}$ at standard precision): <lang parigp>sum(n=1,1000,1./n^2)</lang>

Approximate solution (accurate to $9\cdot 10^{-11}$ at standard precision): <lang parigp>zeta(2)-intnum(x=1000.5,[1],1/x^2)</lang> or <lang parigp>zeta(2)-1/1000.5</lang>

Pascal

<lang pascal>Program SumSeries;

var

 S: double;
 i: integer;

function f(number: integer): double; begin

 f := 1/(number*number);

end;

begin

 S := 0;
 for i := 1 to 1000 do
   S := S + f(i);
 writeln('The sum of 1/x^2 from 1 to 1000 is: ', S:10:8);
 writeln('Whereas pi^2/6 is:                  ', pi*pi/6:10:8);

end.</lang> Output:

The sum of a series from 1 to 1000 is: 1.64393457
Whereas pi^2/6 is:                     1.64493407

Perl

<lang perl>my $sum = 0; $sum += 1 / $_ ** 2 foreach 1..1000; print "$sum\n";</lang> or <lang perl>use List::Util qw(reduce); $sum = reduce { $a + 1 / $b ** 2 } 0, 1..1000; print "$sum\n";</lang>

Perl 6

(Some of these work with rakudo, and others with niecza. Eventually they'll all work everywhere...)

In general, the $nth partial sum of a series whose terms are given by a unary function &f is

So what's needed in this case is

<lang perl6>say [+] map { 1 / $^n**2 }, 1 .. 1000; say [+] map 1 / * ** 2, 1 .. 1000; # same thing</lang>

Or, using the "hyper" metaoperator to vectorize, we can use a more "point free" style while keeping traditional precedence: <lang perl6>say [+] 1 «/« (1..1000) »**» 2;</lang>

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:

<lang perl6>say [+] 1 X/ (1..1000 X** 2);</lang> 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.

In a lazy language like Perl 6, 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: <lang perl6>constant @x = [\+] 0, { 1 / ++(state $n) ** 2 } ... *; say @x[1000]; # prints 1.64393456668156</lang> Note that infinite constant sequences can be lazily generated in Perl 6, or this wouldn't work so well...

Perhaps the cleanest style is to combine these approaches with a more FP look:

<lang perl6>constant ζish = [\+] map -> \𝑖 { 1 / 𝑖**2 }, 1..*; say ζish[1000];</lang>

Finally, if list comprehensions are your hammer, you can nail it this way. Though defining a inverse square superscript operator is obviously just showing off. :-)

<lang perl6>sub postfix:<⁻²> ($x) { 1 / ($x * $x) } say [+] ($_⁻² for 1..1000);</lang> 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.

PicoLisp

<lang 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</lang>

Output:

1.643935

Pike

<lang Pike>array(int) x = enumerate(1000,1,1); `+(@(1.0/pow(x[*],2)[*])); Result: 1.64393</lang>

PL/I

<lang 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); </lang> Output:

1.64393456668155980E+0000

Pop11

<lang pop11>lvars s = 0, j; for j from 1 to 1000 do

   s + 1.0/(j*j) -> s;

endfor;

s =></lang>

PostScript

<lang> /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 </lang> Output: <lang> 1.64393485 </lang>

Library: initlib

<lang postscript> % 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 </lang>

PowerShell

<lang powershell>$x = 1..1000 `

      | ForEach-Object { 1 / ($_ * $_) } `
      | Measure-Object -Sum

Write-Host Sum = $x.Sum</lang>

Prolog

Works with SWI-Prolog. <lang Prolog>sum(S) :-

       findall(L, (between(1,1000,N),L is 1/N^2), Ls),
       sumlist(Ls, S).

</lang> Ouptput :

?- sum(S).
S = 1.643934566681562.

PureBasic

<lang PureBasic>Define i, sum.d

For i=1 To 1000

 sum+1.0/(i*i)

Next i

Debug sum</lang> Answer = 1.6439345666815615

Python

<lang python>print ( sum(1.0 / (x * x) for x in range(1, 1001)) )</lang>

R

<lang r>print( sum( 1/seq(1000)^2 ) )</lang>

REXX

<lang>/*REXX program sums the first N terms of 1/(i**2), i=1 ──► N.*/ arg terms . /*get number of terms to be used.*/ if terms== then terms=1000 /*Not specified? Use the default*/ numeric digits 60 /*use 60 digits, 9 is the default*/ say 'The sum of' terms "terms is:" say S(2,terms) exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────S subroutine────────────────────────*/ S: procedure; parse arg pow,terms sum=0 /*initialize the sum to zero. */

              do j=1  to terms        /*compute for   n   terms.       */
              sum=sum+1/j**pow
              end   /*j*/

return sum</lang> output when using the default input

The sum of 1000 terms is:
1.64393456668155980313905802382221558965210344649368531671713

output when using the input of: 10000

The sum of 10000 terms is:
1.64483407184805976980608183331031090353799751949684175308996

output when using the input of: 100000

The sum of 100000 terms is:
1.64492406689822626980574850331269185564752132981156034248806

RLaB

<lang RLaB> >> sum( (1 ./ [1:1000]) .^ 2 ) - const.pi^2/6 -0.000999500167 </lang>

Ruby

<lang ruby>puts (1..1000).inject(0) {|sum, x| sum + 1.0 / x ** 2}</lang>

Scala

<lang scala>scala> 1 to 1000 map (x => 1.0 / (x * x)) sum res30: Double = 1.6439345666815615</lang>

Scheme

<lang 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</lang>

More idiomatic way (or so they say) by tail recursion: <lang scheme>(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</lang>

Seed7

<lang 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;
   writeln(sum digits 6 lpad 8);
 end func;</lang>

Slate

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

<lang slate>((1 to: 1000) reduce: [|:x :y | x + (y squared reciprocal as: Float)]).</lang>

Smalltalk

<lang smalltalk>( (1 to: 1000) fold: [:sum :aNumber |

 sum + (aNumber squared reciprocal) ] ) asFloat displayNl.</lang>

SQL

<lang sql>create table sequence ( n real )

insert into sequence values (0) insert into sequence values (1) insert into sequence select 2+n from sequence insert into sequence select 4+n from sequence insert into sequence select 8+n from sequence insert into sequence select 16+n from sequence insert into sequence select 32+n from sequence insert into sequence select 64+n from sequence insert into sequence select 128+n from sequence insert into sequence select 256+n from sequence insert into sequence select 512+n from sequence

select sum(1/n) from sequence where n>=1 and n<=1000</lang>

This produces a result set with a value which is something like 7.48547092382796

Standard ML

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

Tcl

Works with: Tcl version 8.5

<lang tcl>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</lang>

Library: Tcllib (Package: struct::list)

<lang tcl>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::+

}

sum_of $S [range 1 1001] ;# ==> 1.6439345666815615</lang>

The helper range procedure is: <lang tcl># 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

}</lang>

TI-89 BASIC

UnixPipes

<lang bash>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</lang>

Unicon

See Icon.

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. <lang Ursala>#import flo

import nat

cast %e

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

1.643935e+00

Vala

<lang 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()); } </lang>

Output:

1.6439345666815615

XPL0

<lang 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); ]</lang>

Output:

    1.64393

Yorick

<lang yorick>(1./indgen(1:1000)^2)(sum)</lang>