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
<lang 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;</lang>
ALGOL 68
MODE RANGE = STRUCT(INT lwb, upb);
PROC sum = (PROC (INT)LONG REAL f, RANGE range)LONG REAL:(
LONG REAL sum := LENG 0.0;
FOR i FROM lwb OF range TO upb OF range DO
sum := sum + f(i)
OD;
sum
);
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))
Output:
Sum of f(x) from +1 to +100 is +1.63498390018489e +0.
C++
<lang 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 ) );
} </lang>
Common Lisp
<lang lisp>(loop for x from 1 to 1000 summing (/ (expt x 2)))</lang>
D
<lang 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));
} </lang>
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]
Icon
procedure main() local i, sum sum := 0 & i := 0 every sum +:= 1.0/((| i +:= 1 ) ^ 2) \1000 write(sum) end
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 1r6p2 NB. As a constant (J has a rich constant notation)
1.64493
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>
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}]
MAXScript
total = 0
for i in 1 to 1000 do
(
total += 1.0 / pow i 2
)
print total
Nial
|sum (1 / power (count 1000) 2) =1.64393
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
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
<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>
Pop11
lvars s = 0, j;
for j from 1 to 1000 do
s + 1.0/(j*j) -> s;
endfor;
s =>
Python
<lang python>print sum(1.0 / x ** 2 for x in range(1, 1001))</lang>
R
print( sum( 1/seq(1000)^2 ) )
Ruby
<lang ruby>puts (1..1000).inject(0) {|sum, x| sum + 1.0 / x ** 2}</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>
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