Sum of a series: Difference between revisions

 

For this task, use:

 

 

 

 

 

is the solution of the [[wp:Basel problem|Basel problem]].

 

=={{header|ACL2}}==

(if (zp max-x)

0

(+ (/ (* max-x max-x))

 

=={{header|ActionScript}}==

{

var sum:Number = 0;

return sum;

}

=={{header|Ada}}==

 

procedure Sum_Series is

Put(Item => Sum, Aft => 10, Exp => 0);

New_Line;

 

=={{header|Aime}}==

Invsqr(real n)

{

}

 

o_byte('\n');

 

 

=={{header|ALGOL 68}}==

 

PROC sum = (PROC (INT)LONG REAL f, RANGE range)LONG REAL:(

 

test:(

PROC f = (INT x)LONG REAL: LENG REAL(1) / LENG REAL(x)**2;

Output:

<pre>

</pre>

 

=={{header|APL}}==

 

=={{header|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.

While A_Index <= 1000

sum += 1/A_Index**2

 

=={{header|AWK}}==

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

s = 1 / x ^ 2

end function

sum = ret

end function

 

 

sum += 1/i%^2

NEXT

 

=={{header|bc}}==

return(1 / (x * x))

}

 

scale = 20

 

{{Out}}

<pre>1.64393456668155979824</pre>

 

=={{header|Befunge}}==

Emulates fixed point arithmetic with a 32 bit integer so the result is not very accurate.

v*8555$_^#!:-1+*"~"g01g00+/*:\***<

<@$_,#!>#:<+*<v+*86%+55:p00<6\0/**

{{out}}

<pre>1.643934</pre>

 

=={{header|Bracmat}}==

& 0:?S

& whl'(1+!i:~>1000:?i&!i^-2+!S:?S)

& out$!S

& out$(flt$(!S,10))

Output:

<pre>8354593848314...../5082072010432..... (1732 digits and a slash)

 

=={{header|Brat}}==

 

=={{header|C}}==

 

double Invsqr(double n)

return 0;

 

=={{header|C sharp|C#}}==

{

static void Main(string[] args)

Console.ReadLine();

}

 

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

 

{

static void Main(string[] args)

Console.ReadLine();

}

 

=={{header|CLIPS}}==

(deffunction partial-sum-S

(?start ?stop)

)

(return ?sum)

 

Usage:

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

PROGRAM-ID. sum-of-series.

 

 

GOBACK

{{out}}

<pre>

 

=={{header|CoffeeScript}}==

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

 

=={{header|Common Lisp}}==

 

=={{header|D}}==

===More Procedural Style===

 

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

void main() {

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

{{out}}

<pre>Sum: 1.64393</pre>

===More functional Style===

Same output.

 

enum series(alias F) = (in int end, in int start=1)

void main() {

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

 

=={{header|Delphi}}==

unit Form_SumOfASeries_Unit;

 

end.

 

{{out}}

<pre>1.64393456668156</pre>

=={{header|DWScript}}==

 

var s : Float;

for var i := 1 to 1000 do

 

PrintLn(s);

 

=={{header|E}}==

 

 

=={{header|EchoLisp}}==

(lib 'math) ;; for (sigma f(n) nfrom nto) function

(Σ (λ(n) (// (* n n))) 1 1000)

(// (* PI PI) 6)

→ 1.6449340668482264

 

=={{header|Eiffel}}==

note

description: "Compute the n-th term of a series"

end

 

 

=={{header|Elixir}}==

 

 

<pre>

</pre>

 

=={{header|Erlang}}==

 

 

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

This is based on the [[BASIC]] example.

function s( atom x )

return 1 / power( x, 2 )

end function

 

 

=={{header|Ezhil}}==

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

 

பதிப்பி "அதன் தொடர்க் கூட்டல் " தொடர்க்கூட்டல்(அ)

 

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

Within 'fansh':

 

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

1.6439345666815615

 

=={{header|Forth}}==

0e

bounds do

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

1 1000 sum f. \ 1.64393456668156

 

=={{header|Fortran}}==

In ISO Fortran 90 and later, use SUM intrinsic:

real :: result

 

 

=={{header|GAP}}==

 

# Computing an approximation of a rationnal (giving a string)

Approx(a, 10);

"1.6439345666"

 

=={{header|GEORGE}}==

0 (s)

1, 1000 rep (i)

]

P

Output:-

<pre>

 

=={{header|Go}}==

 

import ("fmt"; "math")

}

fmt.Println("computed:", sum)

Output:

<pre>known: 1.6449340668482264

=={{header|Groovy}}==

Start with smallest terms first to minimize rounding error:

 

Output:

=={{header|Haskell}}==

With a list comprehension:

With higher-order functions:

In [http://haskell.org/haskellwiki/Pointfree point-free] style:

 

=={{header|HicEst}}==

a = 1 / $^2

 

=={{header|Icon}} and {{header|Unicon}}==

local i, sum

sum := 0 & i := 0

every sum +:= 1.0/((| i +:= 1 ) ^ 2) \1000

write(sum)

 

or

 

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

write(sum)

 

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:

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

 

=={{header|IDL}}==

 

 

=={{header|J}}==

+/ % *: >: i. 1000

1.64393

1r6p2 NB. As a constant (J has a rich constant notation)

 

=={{header|Java}}==

public static double f(double x){

return 1/(x*x);

System.out.println("Sum of f(x) from " + start + " to " + end +" is " + sum);

}

 

=={{header|JavaScript}}==

var s = 0;

for ( ; a <= b; a++) s += fn(a);

}

 

=={{header|jq}}==

 

Directly:

 

s(1000)

{{Out}}

1.6439345666815615

Using a generic summation wrapper function allows problems specified in "sigma" notation to be solved using syntax that closely resembles that notation:

 

 

 

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

 

=={{header|Julia}}==

Using a higher-order function:

 

1.643934566681559

 

julia> pi^2/6

1.6449340668482264

 

A simple loop is more optimized:

 

s = 0.0

for k = 1:n

 

julia> f(1000)

 

=={{header|K}}==

ssr 1+!1000

 

=={{header|Lang5}}==

 

 

 

=={{header|Lasso}}==

local(sum = 0)

loop(-from=#k,-to=#n) => {

return #sum

}

{{out}}

<pre>1.643935</pre>

=== With <code>lists:foldl</code> ===

 

(defun sum-series (nums)

(lists:foldl

(lambda (x) (/ 1 x x))

nums)))

 

=== With <code>lists:sum</code> ===

 

(defun sum-series (nums)

(lists:sum

(lambda (x) (/ 1 x x))

nums)))

 

Both have the same result:

 

> (sum-series (lists:seq 1 100000))

1.6449240668982423

 

=={{header|Liberty BASIC}}==

for i =1 to 1000

sum =sum +1 /( i^2)

 

end

=={{header|Logo}}==

localmake "sigma 0

for [i :a :b] [make "sigma :sigma + invoke :fn :i]

print series "zeta.2 1 1000

make "pi (radarctan 0 1) * 2

 

=={{header|Lua}}==

sum = 0

for i = 1, 1000 do sum = sum + 1/i^2 end

print(sum)

=={{header|Lucid}}==

where

num = 1 fby num + 1;

ssum = ssum + 1/(num * num)

 

This is the straightforward solution of the task:

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

or better:

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:

Other ways include (exact, approximate,exact,approximate):

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

Plus@@Table[1/x^2, {x, 1, 1000}]

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

 

835459384831496894781878542648[806 digits]396236858699094240207812766449

(%o45) ------------------------------------------------------------------------

 

(%i46) sum(1/x^2, x, 1, 1000),numer;

 

=={{header|MAXScript}}==

for i in 1 to 1000 do

(

total += 1.0 / pow i 2

)

 

=={{header|МК-61/52}}==

+ П0 ИП1 1 0 0 0 - x>=0 03

 

=={{header|ML}}==

 

==={{header|Standard ML}}===

(* 1.64393456668 *)

List.foldl op+ 0.0 (List.tabulate(1000, fn x => 1.0 / Math.pow(real(x + 1),2.0)))

 

==={{header|mLite}}===

Output:

<pre>1.6439345666815549</pre>

 

=={{header|MMIX}}==

y IS $2 % id

z IS $3 % z = sum series

PBNP t,1B } z = sum

GO $127,prtFlt print sum --> StdOut

Output:

<pre>~/MIX/MMIX/Rosetta> mmix sumseries

0.1643934566681562e1</pre>

 

=={{header|Modula-3}}==

Modula-3 uses D0 after a floating point number as a literal for <tt>LONGREAL</tt>.

 

IMPORT IO, Fmt, Math;

IO.Put(Fmt.LongReal(sum));

IO.Put("\n");

Output:

<pre>

 

=={{header|MUMPS}}==

SOAS(N)

NEW SUM,I SET SUM=0

.SET SUM=SUM+(1/((I*I)))

QUIT SUM

This is an extrinsic function so the usage is:

<pre>

1.643934566681559806

</pre>

 

=={{header|NewLISP}}==

(for (i 1 1000)

(inc s (div 1 (* i i))))

 

=={{header|Nim}}==

 

 

=={{header|Objeck}}==

bundle Default {

class SumSeries {

}

}

 

=={{header|OCaml}}==

let result = ref 0. in

for i = a to b do

result := !result +. fn i

done;

 

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

 

or in a functional programming style:

let rec aux i r =

if i > b then r

in

aux a 0.

Simple recursive solution:

 

=={{header|Octave}}==

Given a vector, the sum of all its elements is simply <code>sum(vector)</code>; a range can be ''generated'' through the range notation: <code>sum(1:1000)</code> computes the sum of all numbers from 1 to 1000. To compute the requested series, we can simply write:

 

 

=={{header|Oforth}}==

 

 

Usage :

 

{{out}}

Conventionally like elsewhere:

 

def var n as int no-undo.

 

end.

 

 

or like this:

 

 

repeat n = 1 to 1000 :

end.

 

 

=={{header|Oz}}==

With higher-order functions:

fun {SumSeries S N}

{FoldL {Map {List.number 1 N 1} S}

end

in

 

Iterative:

R = {NewCell 0.}

in

end

@R

 

=={{header|PARI/GP}}==

Exact rational solution:

 

Real number solution (accurate to <math>3\cdot10^{-36}</math> at standard precision):

 

Approximate solution (accurate to <math>9\cdot10^{-11}</math> at standard precision):

or

 

=={{header|Pascal}}==

 

var

begin

end;

 

writeln('Whereas pi^2/6 is: ', pi*pi/6:10:8);

</pre>

 

=={{header|Perl}}==

$sum += 1 / $_ ** 2 foreach 1..1000;

or

$sum = reduce { $a + 1 / $b ** 2 } 0, 1..1000;

An other way of doing it is to define the series as a closure:

my @S = map &$S, 1 .. 1000;

 

 

=={{header|PHP}}==

 

/**

 

echo sum_of_a_series(1000,1);

{{out}}

<pre>1.6439345666816</pre>

 

=={{header|PL/I}}==

s = 0;

 

end;

 

 

{{out}}

=={{header|Pop11}}==

 

for j from 1 to 1000 do

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

endfor;

 

 

=={{header|PostScript}}==

/aproxriemann{

/x exch def

 

1000 aproxriemann

Output:

1.64393485

 

{{libheader|initlib}}

% 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

 

=={{header|PowerShell}}==

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

| Measure-Object -Sum

 

=={{header|Prolog}}==

Works with SWI-Prolog.

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

sumlist(Ls, S).

Ouptput :

<pre>?- sum(S).

 

=={{header|PureBasic}}==

 

For i=1 To 1000

Next i

 

<tt>

Answer = 1.6439345666815615

 

=={{header|Python}}==

 

=={{header|R}}==

 

=={{header|Racket}}==

A solution using Typed Racket:

 

#lang typed/racket

 

(for/sum: : Real ([k : Natural (in-range 1 (+ n 1))])

(/ 1.0 (* k k))))

 

=={{header|Raven}}==

{{out}}

<pre>1.64393</pre>

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

 

=={{header|REXX}}==

 

<pre>

The sum of 1000 terms is: 1.64393456668155980313905802382221558965210344649368531671713

</pre>

 

<pre>

The sum of 10 terms is: 1.54976773116654069035021415973796926177878558830939783320736

The sum of 1000000000 terms is: 1.64493406584822643697241516647935852255228323457346510444171

</pre>

 

1.64493406^{684822643647241516664602518921894990120679843773556}

 

 

If the &nbsp; '''old''' &nbsp; REXX variable would be set to &nbsp; '''1.64''' &nbsp; (instead of &nbsp; '''1'''), the first noise digits could be bypassed to make the display ''cleaner''.

<pre>

 

</pre>

 

=={{header|RLaB}}==

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

-0.000999500167

 

=={{header|Ruby}}==

 

=={{header|Run BASIC}}==

for i =1 to 1000

sum = sum + 1 /( i^2)

next i

 

=={{header|Rust}}==

 

=={{header|SAS}}==

s=0;

do n=1 to 1000;

e=s-constant('pi')**2/6;

put s e;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

(do ((i a (+ i 1))

(result 0 (+ result (fn i))))

 

(sum 1 1000 (lambda (x) (/ 1 (* x x)))) ; fraction

 

More idiomatic way (or so they say) by tail recursion:

(let loop ((f f) (s 0))

(if (> f to)

;; whether you get a rational or a float depends on implementation

(invsq 1 1000) ; 835459384831...766449/50820...90400000000

 

=={{header|Seed7}}==

include "float.s7i";

 

end for;

writeln(sum digits 6 lpad 8);

 

=={{header|Sidef}}==

 

=={{header|Slate}}==

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

 

 

=={{header|Smalltalk}}==

 

=={{header|SQL}}==

-- this is postgresql specific, fill the table

insert into t1 (select generate_series(1,1000)::real);

select 1/(n*n) as recip from t1

) select sum(recip) from tt;

Result of select (with locale DE):

<pre>

(1 Zeile)

</pre>

 

=={{header|Swift}}==

func sumSeries(var n: Int) -> Double {

var ret: Double = 0

 

output: 1.64393456668156

 

Swift also allows extension to datatypes. Here's similar code using an extension to Int.

 

 

y = 1000.sumSeries()

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

 

proc partial_sum {func - start - stop} {

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

 

 

{{tcllib|struct::list}}

package require struct::list

 

}

 

 

The helper <code>range</code> procedure is:

proc range args {

foreach {start stop step} [switch -exact -- [llength $args] {

}

return $range

 

=={{header|TI-89 BASIC}}==

 

 

=={{header|TXR}}==

Variant A1: limit the list generation inside the <code>gen</code> operator.

 

 

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

 

 

Variant B: generate lazy integer range, and pump it through a series of function with the help of the <code>chain</code> functional combinator and the <code>op</code> partial evaluation/binding operator.

 

 

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

 

 

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

 

 

=={{header|UnixPipes}}==

b=$1;res=$2

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

}

 

 

=={{header|Ursala}}==

function, plus. The rest the expression constructs the series

by inverting the square of each number in the list from 1 to 1000.

#import nat

 

#cast %e

 

output:

<pre>1.643935e+00</pre>

 

=={{header|Vala}}==

public static void main(){

int i, start = 1, end = 1000;

stdout.printf("%s\n", sum.to_string());

}

 

Output:

1.6439345666815615

</pre>

 

=={{header|Wortel}}==

#~V1Sn ; number expression which stands for: square push(1) swap divide

!* ; maps the number expression over the list

 

=={{header|XPL0}}==

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

 

Output:

 

=={{header|Yorick}}==

 

=={{header|zkl}}==