Sum a series

From Rosetta Code

Display the sum of a finite series for a given range.

For this task, use S(x) = 1/x^2, from 1 to 1000. (This approximates the Riemann zeta function. The Basel problem solved this: zeta(2) = p²/6.)

Contents 1 Ada 2 C++ 3 Common Lisp 4 D 5 E 6 Forth 7 Fortran 8 Haskell 9 IDL 10 J 11 Java 12 JavaScript 13 Logo 14 Lucid 15 Mathematica 16 OCaml 17 OpenEdge/Progress 18 Perl 19 Pop11 20 Python 21 R 22 Scheme 23 UnixPipes

[edit] Ada

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

[edit] C++

#include <iostream>
 
double f(double x);
 
int main()
{
        unsigned int start = 1;
        unsigned int end = 1000;
        double sum = 0;
        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 / ( x * x ) );
}
 

[edit] Common Lisp

(loop for x from 1 to 1000 
      sum (/ (expt x 2)))

[edit] D

 
import std.stdio, std.traits;
 
ReturnType!(TF) series(TF)(TF func, int end, int start=1) {
    ReturnType!(TF) sum = 0;
    for (int i = start; i <= end; i++)
        sum += func(i);
    return sum;
}
 
void main() {
    writefln("Sum: ", series((int n){return 1.0L / (n*n);}, 1_000));
}
 

[edit] E

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

[edit] 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

[edit] Fortran

In ISO Fortran 90 and later, use SUM intrinsic:

 real, dimension(1000) :: a = (/ (1.0/(i*i), i=1, 1000) /)
 real :: result
 
 result = sum(a);

[edit] Haskell

With a list comprehension:

sum [1 / x ^ 2 | x <- [1..1000]]

With higher-order functions:

sum $ map (\x -> 1 / x ^ 2) [1..1000]

In point-free style:

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

[edit] IDL

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

[edit] J

   NB. sum of inverse of square 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

[edit] 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);
    }
}

[edit] 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

[edit] 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

[edit] Lucid

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

[edit] Mathematica

This is the straightforward solution of the task:

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

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

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

Alternatively, get Mathematica to do the whole calculation in floating point by using a floating point value in the formula:

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

[edit] OCaml

let sum a b fn =
  let result = ref 0. in
  for i = a to b do
    result := !result +. fn i
  done;
  !result

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

[edit] OpenEdge/Progress

Conventionally like elsewhere:

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

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

display dcResult .

or like this:

def var n as int no-undo.

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

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

[edit] Perl

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

[edit] Pop11

lvars s = 0, j;
for j from 1 to 1000 do
    s + 1.0/(j*j) -> s;
endfor;

s =>

[edit] Python

print sum(1.0 / x ** 2 for x in range(1, 1001))

[edit] R

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

[edit] 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

[edit] UnixPipes

term() {
   b=$1;res=$2
   echo "scale=5;1/($res*$res)+$b" | bc
}

sum() {
  (read B; res=$1;
  test -n "$B" && (term $B $res) || (term 0 $res))
}

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

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