Sum of a series
You are encouraged to solve this task according to the task description, using any language you may know.
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) = p2/6.)
Ada
<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;</ada>
C++
<cpp>#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 ) );
} </cpp>
Common Lisp
<lisp>(defun series (n) (if (= n 1) 1.0 (+ (/ 1 (expt n 2)) (series (- n 1)))))
(series 1000)</lisp>
D
<d>module series ; import std.stdio ;
T series(T)(T function(int) t, int end, int start = 1 /* 0 if zero base*/ ) {
T sum = 0 ; for(int i = start ; i <= end ; i++) sum += t(i) ; return sum ;
} real term(int n){
return 1.0L/(n*n) ;
} void main(){
writef("sum@[1..1000] = ", series(&term, 1000)) ;
}</d>
E
pragma.enable("accumulator") accum 0 for x in 1..1000 { _ + 1 / x ** 2 }
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
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);
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]
IDL
print,total( 1/(1+findgen(1000))^2)
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
Java
<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); }
}</java>
JavaScript
<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</javascript>
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
Lucid
series = ssum asa n >= 1000 where num = 1 fby num + 1; ssum = ssum + 1/(num * num) end;
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}]
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) ) .
Perl
<perl>my $sum = 0; map { $sum += 1 / ( $_ * $_ ) } (1..1000); print "$sum\n"; </perl>
Pop11
lvars s = 0, j; for j from 1 to 1000 do s + 1.0/(j*j) -> s; endfor; s =>
Python
<python>print sum(1.0 / x ** 2 for x in xrange(1, 1001))</python>
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