Content added Content deleted

Inline

Revision as of 22:24, 2 December 2021

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

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.

For this task, use:

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

and compute

S_{1000}

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

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

is the solution of the Basel problem.

11l

Translation of: Python

<lang 11l>print(sum((1..1000).map(x -> 1.0/x^2)))</lang>

Output:

1.64393

360 Assembly

<lang 360asm>* Sum of a series 30/03/2017 SUMSER CSECT

        USING  SUMSER,12          base register
        LR     12,15              set addressability
        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</lang>

Output:

       1.6439

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>

Action!

Library: Action! Tool Kit

<lang 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)
   RealAdd(res,a,b)
   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</lang>

Output:

Screenshot from Atari 8-bit computer

s(1000)=1.64392967

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

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

)</lang> Output:

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

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

Output:

 1.64393

APL

AppleScript

Translation of: JavaScript

Translation of: Haskell

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

Output:

Arturo

<lang rebol>series: map 1..1000 => [1.0/&^2] print [sum series]</lang>

Output:

1.643934566681561

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. <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>

BASIC256

Works with: True BASIC

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

BBC BASIC

<lang bbcbasic> FOR i% = 1 TO 1000

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

True BASIC

Works with: BASIC256

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

Yabasic

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

bc

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

Output:

1.64393456668155979824

Beads

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

Output:

1.6439345666815615

Befunge

Emulates fixed point arithmetic with a 32 bit integer so the result is not very accurate. <lang befunge>05558***>::"~"%00p"~"/10p"( }}2"*v v*8555$_^#!:-1+*"~"g01g00+/*:\***< <@$_,#!>#:<+*<v+*86%+55:p00<6\0/**

  "."\55+%68^>\55+/00g1-:#^_$</lang>

Output:

1.643934

Bracmat

<lang bracmat>( 0:?i & 0:?S & whl'(1+!i:~>1000:?i&!i^-2+!S:?S) & out$!S & out$(flt$(!S,10)) );</lang> Output:

8354593848314...../5082072010432.....  (1732 digits and a slash)
1,6439345667*10E0

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

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>

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>

COBOL

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

Output:

1.643933784000000120

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>

Crystal

Translation of: Ruby

Output:

1.6439345666815615
1.6447340868469014
1.6448340618480652
1.6449340668482264

D

More Procedural Style

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

}</lang>

Output:

Sum: 1.64393

More functional Style

Same output. <lang d>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));

}</lang>

Dart

Translation of: Scala

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

}</lang>

Translation of: F#

<lang dart>f(double x) {

 if (x == 0)
   return x;
 else
   return (1.0 / (x * x)) + f(x - 1.0);

}

main() {

 print(f(1000));

}</lang>

Delphi

<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, 1000)));
 except
   M_Log.Lines.Add('Error');
 end;

end;

end.

</lang>

Output:

1.64393456668156

DWScript

<lang delphi> var s : Float; for var i := 1 to 1000 do

  s += 1 / Sqr(i);

PrintLn(s); </lang>

Dyalect

Translation of: Swift

<lang dyalect>func Integer.sumSeries() {

   var ret = 0

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

ret

}

var x = 1000 print(x.sumSeries())</lang>

Output:

1.6439345666815615

E

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

EchoLisp

<lang lisp> (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

</lang>

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. <lang edsac>

[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
 GKA3FT34@S4DE13@T4DSDTDE2@T4DADLDTDA4DLDE8@RDU4DLDA35@
 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
           A3F  T11@   [set up return to caller as usual]
           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]
           AD  A#@  T#@             [add 1/k^2 into sum]
           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.]
           TFT#@A3@T14@TFA14@TFA58@G120FADA#@T#@A14@S2@U14@S2FE55@TDA#@TD
           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]

</lang>

Output:

LO TO HI 1.6439345641
HI TO LO 1.6439345641

Eiffel

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

</lang>

Elena

ELENA 4.x : <lang elena>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

}</lang>

Output:

1.643933566682

Elixir

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

Emacs Lisp

<lang Emacs Lisp> (defun serie (n)

 (if (< 0 n)
     (apply '+ (mapcar (lambda (k) (/ 1.0 (* k k) )) (number-sequence 1 n) ))
   (error "input error") ))

(insert (format "%.10f" (serie 1000) )) </lang> Output:

1.6439345667

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>

Excel

LAMBDA

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

(See LAMBDA: The ultimate Excel worksheet function)

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

Works with: Office 365 betas 2021

<lang lisp>sumOfSeries =LAMBDA(f,

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

)

inverseSquare =LAMBDA(n,

   1 / (n ^ 2)

)</lang>

Output:

	fx	=sumOfSeries(inverseSquare)(A2)
	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

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

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

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

 எண்2 = 0

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

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

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

 முடி

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

முடி

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

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

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

For a much more elegant and FP style of solving this problem, use: <lang fsharp> Seq.sum [for x in [1..1000] do 1./(x * x |> float)] </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>

Fermat

<lang fermat>Sigma<k=1,1000>[1/k^2]</lang>

Output:

 83545938483149689478187854264854884386044454314086472930763839512603803291207881839588904977469387999844962675327115010933 `
 903589145654299730231109091124308462732153297321867661093162618281746011828755017021645889046777854795025297006943669294 `
 330752479399654716368801794529682603741344724733173765262964463970763934463926259796895140901128384286333311745462863716 `
 753134735154188954742414035836608258393970996630553795415075904205673610359458498106833291961256452756993199997231825920 `
 203667952667546787052535763624910912251107083702817265087341966845358732584971361645348091123849687614886682117125784781 `
 422103460192439394780707024963279033532646857677925648889105430050030795563141941157379481719403833258405980463950499887 `
 302926152552848089894630843538497552630691676216896740675701385847032173192623833881016332493844186817408141003602396236 `
 858699094240207812766449 / 50820720104325812617835292273000760481839790754374852703215456050992581046448162621598030244504097 `
 240825920773913981926305208272518886258627010933716354037062979680120674828102224650586465553482032614190502746121717248 `
 161892239954030493982549422690846180552358769564169076876408783086920322038142618269982747137757706040198826719424371333 `
 781947889528085329853597116893889786983109597085041878513917342099206896166585859839289193299599163669641323895022932959 `
 750057616390808553697984192067774252834860398458100840611325353202165675189472559524948330224159123505567527375848194800 `
 452556940453530457590024173749704941834382709198515664897344438584947842793131829050180589581507273988682409028088248800 `
 576590497216884808783192565859896957125449502802395453976401743504938336291933628859306247684023233969172475385327442707 `
 968328512729836445886537101453118476390400000000;  or  1.6439345666815598031390580238222155896521

Fish

<lang fish>0&aaa**>::*1$,&v

   ;n&^?:-1&+ <</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> Or in Fortran 77: <lang fortran> s=0

     do i=1,1000
         s=s+1./i**2
     end do
     write (*,*) s
     end</lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Const pi As Double = 3.141592653589793

Function sumSeries (n As UInteger) As Double

 If n = 0 Then Return 0
 Dim sum As Double = 0
 For k As Integer = 1 To n
   sum += 1.0/(k * k)
 Next
 Return sum

End Function

Print "s(1000) = "; sumSeries(1000) Print "zeta(2) = "; Pi * pi / 6 Print Print "Press any key to quit" Sleep</lang>

Output:

s(1000) =  1.643934566681562
zeta(2) =  1.644934066848226

Frink

Frink can calculate the series with exact rational numbers or floating-point values. <lang frink> sum[map[{|k| 1/k^2}, 1 to 1000]] </lang>

Output:

83545938483149689478187854264854884386044454314086472930763839512603803291207881839588904977469387999844962675327115010933903589145654299730231109091124308462732153297321867661093162618281746011828755017021645889046777854795025297006943669294330752479399654716368801794529682603741344724733173765262964463970763934463926259796895140901128384286333311745462863716753134735154188954742414035836608258393970996630553795415075904205673610359458498106833291961256452756993199997231825920203667952667546787052535763624910912251107083702817265087341966845358732584971361645348091123849687614886682117125784781422103460192439394780707024963279033532646857677925648889105430050030795563141941157379481719403833258405980463950499887302926152552848089894630843538497552630691676216896740675701385847032173192623833881016332493844186817408141003602396236858699094240207812766449/50820720104325812617835292273000760481839790754374852703215456050992581046448162621598030244504097240825920773913981926305208272518886258627010933716354037062979680120674828102224650586465553482032614190502746121717248161892239954030493982549422690846180552358769564169076876408783086920322038142618269982747137757706040198826719424371333781947889528085329853597116893889786983109597085041878513917342099206896166585859839289193299599163669641323895022932959750057616390808553697984192067774252834860398458100840611325353202165675189472559524948330224159123505567527375848194800452556940453530457590024173749704941834382709198515664897344438584947842793131829050180589581507273988682409028088248800576590497216884808783192565859896957125449502802395453976401743504938336291933628859306247684023233969172475385327442707968328512729836445886537101453118476390400000000 (approx. 1.6439345666815598)

Change 1/k^2 to 1.0/k^2 to use floating-point math.

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

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>

Genie

<lang genie>[indent=4] /*

  Sum of series, in Genie
  valac sumOfSeries.gs
  ./sumOfSeries

/

delegate sumFunc(n:int):double

def sum_series(start:int, end:int, f:sumFunc):double

   sum:double = 0.0
   for var i = start to end do sum += f(i)
   return sum

def oneOverSquare(n:int):double

   return (1 / (double)(n * n))

init

   Intl.setlocale()
   print "ζ(2) approximation: %16.15f", sum_series(1, 1000, oneOverSquare)
   print "π² / 6            : %16.15f", Math.PI * Math.PI / 6.0</lang>

Output:

prompt$ valac sumOfSeries.gs
prompt$ ./sumOfSeries
ζ(2) approximation: 1.643934566681561
π² / 6            : 1.644934066848226

GEORGE

<lang GEORGE> 0 (s) 1, 1000 rep (i)

  s 1 i dup × / + (s) ;

] P </lang> Output:-

 1.643934566681561

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> or <lang haskell>(sum . map ((1 /) . (^ 2))) [1 .. 1000]</lang>

or, as a single fold:

<lang haskell>seriesSum f = foldr ((+) . f) 0

inverseSquare = (1 /) . (^ 2)

main :: IO () main = print $ seriesSum inverseSquare [1 .. 1000]</lang>

Output:

1.6439345666815615

Haxe

Procedural

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

}</lang>

Output:

Approximation: 1.64393456668156146
        Exact: 1.64493406684822641

Functional

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

}</lang>

Output:

Same as for procedural

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>

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

<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

ES5

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

or, in a functional idiom:

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

})();</lang>

Output:

ES6

Translation of: Haskell

<lang JavaScript>(() => {

   '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));

})();</lang>

Output:

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: <lang jq>def s(n): reduce range(1; n+1) as $k (0; . + 1/($k * $k) );

s(1000) </lang>

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:

<lang jq>def summation(s): reduce s as $k (0; . + $k);

summation( range(1; 1001) | (1/(. * .) ) )</lang>

An important point is that nothing is lost in efficiency using the declarative and quite elegant approach using "summation".

Jsish

From Javascript ES5.

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

/</lang>

Output:

prompt$ jsish --U sumOfSeries.jsi
sum(1, 1000, function(x) { return 1/(x*x); } ) ==> 1.643934566681561

Julia

Using a higher-order function:

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

julia> pi^2/6 1.6449340668482264 </lang>

A simple loop is more optimized:

<lang Julia>julia> function f(n)

   s = 0.0
   for k = 1:n
     s += 1/k^2
   end
   return s

end

julia> f(1000) 1.6439345666815615</lang>

K

<lang k> ssr: +/1%_sqr

 ssr 1+!1000

1.643935</lang>

Kotlin

<lang scala>// 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}")

}</lang>

Output:

Actual sum is 1.6439345666815615
zeta(2)    is 1.6449340668482264

Lambdatalk

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

Lang5

<lang lang5>1000 iota 1 + 1 swap / 2 ** '+ reduce .</lang>

Lasso

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

Output:

1.643935

LFE

With `lists:foldl`

<lang lisp> (defun sum-series (nums)

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

</lang>

With `lists:sum`

<lang lisp> (defun sum-series (nums)

 (lists:sum
   (lists:map
     (lambda (x) (/ 1 x x))
     nums)))

</lang>

Both have the same result:

<lang lisp> > (sum-series (lists:seq 1 100000)) 1.6449240668982423 </lang>

Liberty BASIC

<lang lb> for i =1 to 1000

 sum =sum +1 /( i^2)

next i

print sum

end </lang>

Lingo

<lang lingo>the floatprecision = 8 sum = 0 repeat with i = 1 to 1000

 sum = sum + 1/power(i, 2)

end repeat put sum -- 1.64393457</lang>

LiveCode

<lang LiveCode>repeat with i = 1 to 1000

   add 1/(i^2) to summ

end repeat put summ //1.643935</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>

Maple

Output:

-Psi(1, 1001)+(1/6)*Pi^2

Mathematica/Wolfram Language

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>

min

Works with: min version 0.19.3

<lang min>0 1 (

 ((dup * 1 swap /) (id)) cleave
 ((+) (succ)) spread

) 1000 times pop print</lang>

Output:

1.643934566681562

MiniScript

<lang 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
   return total

end function

print sum(1, 1000, @zeta) </lang>

Output:

1.643935

МК-61/52

ML

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>

mLite

<lang ocaml>println ` fold (+, 0) ` map (fn x = 1 / x ^ 2) ` iota (1,1000);</lang> Output:

1.6439345666815549

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-2

<lang modula2>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;
   RETURN total;

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

Output:

1.6439E+00

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

NewLISP

<lang NewLISP>(let (s 0)

 (for (i 1 1000)
   (inc s (div 1 (* i i))))
 (println s))</lang>

Nial

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

Nim

Output:

1.643934566681561

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>

Simple recursive solution: <lang ocaml>let rec sum n = if n < 1 then 0.0 else sum (n-1) +. 1.0 /. float (n*n) in sum 1000</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:

Oforth

<lang Oforth>: sumSerie(s, n) 0 n seq apply(#[ s perform + ]) ;</lang>

Usage : <lang Oforth> #[ sq inv ] 1000 sumSerie println</lang>

Output:

1.64393456668156

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>

Panda

<lang panda>sumTemplate:1.0.divide(1..1000.sqr)</lang> Output:

1.6439345666815615

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

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> An other way of doing it is to define the series as a closure: <lang perl>my $S = do { my ($sum, $k); sub { $sum += 1/++$k**2 } }; my @S = map &$S, 1 .. 1000; print $S[-1];</lang>

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

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

Output:

1.6439345666816

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 pli>/* 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>

Potion

<lang potion>sum = 0.0 1 to 1000 (i): sum = sum + 1.0 / (i * i). sum print</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>

Or, as a generalised map, or fold / reduction – (see Catamorphism#Python): <lang 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()</lang>

Output:

The sum of a series:
(1/x^2 over x = 1..1000)
    by seriesSumA -> 1.6439345666815615
    by seriesSumB -> 1.6439345666815615

Q

Output:

1.643935

Quackery

Using the Quackery bignum rational arithmetic suite bigrat.qky.

<lang Quackery> [ $ "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$</lang>

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

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

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

</lang>

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

So what's needed in this case is

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.

With list comprehensions, you can write:

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: <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 Raku, or this wouldn't work so well...

A cleaner style is to combine these approaches with a more FP look:

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

Perhaps the cleanest way is to just define the zeta function and evaluate it for s=2, possibly using memoization: <lang perl6>use experimental :cached; sub ζ($s) is cached { [\+] 1..* X** -$s } say ζ(2)[1000];</lang>

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

<lang Raven>0 1 1000 1 range each 1.0 swap dup * / + "%g\n" print</lang>

Output:

1.64393

Raven uses a 32 bit float, so precision limits the accuracy of the result for large iterations.

Red

<lang Red>Red [] s: 0 repeat n 1000 [ s: 1.0 / n ** 2 + s ] print s </lang>

REXX

sums specific terms

<lang rexx>/*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. */</lang> 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 10^th term. <lang rexx>/*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. */</lang>

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 $\pi$ ²/6, (using 60 digits) showing the correct number (nine) of decimal digits [the superscripting of the digits was edited after-the-fact]:

1.64493406^{684822643647241516664602518921894990120679843773556}

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. <lang rexx>/*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. */</lang> 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

<lang Ring> sum = 0 for i =1 to 1000

   sum = sum + 1 /(pow(i,2))

next decimals(8) see sum </lang>

RLaB

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

Ruby

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

Output:

1.64393456668156

Run BASIC

<lang runbasic> for i =1 to 1000

 sum = sum + 1 /( i^2)

next i print sum</lang>

Rust

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

} </lang>

SAS

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

Sidef

Alternatively, using the reduce{} method: <lang ruby>say (1..1000 -> reduce { |a,b| a + (1 / b**2) })</lang>

Output:

1.64393456668155980313905802382221558965210344649369

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 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; </lang> Result of select (with locale DE):

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

Stata

<lang stata>function series(n) { return(sum((n..1):^-2)) }

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

 -.0009995002</lang>

Swift

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

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

Tcl

Using Expansion Operator and mathop

Works with: Tcl version 8.5

<lang tcl>package require Tcl 8.5 namespace path {::tcl::mathop ::tcl::} ;# Ease of access to mathop commands 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</lang>

Using Loop

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>

Using tcllib

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

}

set S {x {expr {1.0 / $x**2}}}

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-83 BASIC

TI-84 Version

Translation of: TI-89 BASIC

Works with: TI-83 BASIC version TI-84Plus 2.55MP

Output:

1.643934567

TI-83 Version

The TI-83 does not have the new summation notation, and caps lists at 999 entries. <lang ti83b>sum(seq(1/X²,X,1,999))</lang>

Output:

1.643933567

TI-89 BASIC

TXR

Reduce with + operator over a lazily generated list.

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

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

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

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

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.

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

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

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

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

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

Unicon

See Icon.

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>

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

VBA

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

Output:

 1,64393456668156

VBScript

<lang vb>' Sum of a series

   for i=1 to 1000
       s=s+1/i^2
   next
   wscript.echo s </lang>

Output:

1.64393456668156

Visual Basic .NET

Translation of: VBScript

Works with: Visual Basic .NET version 2013

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

Output:

1.64393456668156

WDTE

<lang WDTE>let s => import 'stream';

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

</lang>

Output:

1.643933567

Wortel

<lang wortel>@sum !*#~V1Sn @to 1000 ; returns 1.6439345666815615</lang> <lang wortel>@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</lang>

Wren

<lang ecmascript>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)")</lang>

Output:

s(1000) = 1.6439345666816
zeta(2) = 1.6449340668482

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

Output:

1.6439346

0 OK, 60:1

Revision as of 22:24, 2 December 2021

More Procedural Style

More functional Style

LAMBDA

Procedural

Functional

Icon and Unicon

ES5

ES6

!EXPECTSTART!

!EXPECTEND!

With lists:foldl

With lists:sum

Mathematica/Wolfram Language

With `lists:foldl`

With `lists:sum`