Sum of a series: Difference between revisions

{{trans|Python}}

{{out}}

=={{header|360 Assembly}}==

SUMSER CSECT

USING SUMSER,12 base register

COPY FORMATF formatf code

PG DC CL80' ' buffer

{{out}}

<pre>

=={{header|ACL2}}==

(if (zp max-x)

0

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

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

PROC Calc(CARD n REAL POINTER res)

PrintF("s(%U)=",n)

PrintRE(res)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_a_series.png Screenshot from Atari 8-bit computer]

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

{

0;

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

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

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

Output:

<pre>

=={{header|ALGOL W}}==

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.

integer k;

% computes the sum of a series from lo to hi using Jensen's Device %

end;

write( r_format := "A", r_w := 8, r_d := 5, sum( k, 1, 1000, 1 / ( k * k ) ) )

{{out}}

<pre>

=={{header|APL}}==

=={{header|AppleScript}}==

{{Trans|JavaScript}}

{{Trans|Haskell}}

-- seriesSum :: Num a => (a -> a) -> [a] -> a

end script

end if

{{Out}}

=={{header|Arturo}}==

{{out}}

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

==={{header|BASIC256}}===

{{works with|True BASIC}}

function sumSeries(n)

if n = 0 then sumSeries = 0

print "zeta(2) = "; pi * pi / 6

end

==={{header|BBC BASIC}}===

sum += 1/i%^2

NEXT

==={{header|True BASIC}}===

{{works with|BASIC256}}

FUNCTION sumSeries(n)

IF n = 0 then

PRINT "zeta(2) = "; pi * pi / 6

END

==={{header|Yabasic}}===

sub sumSeries(n)

if n = 0 then return 0 : fi

print "zeta(2) = ", pi * pi / 6

end

=={{header|bc}}==

return(1 / (x * x))

}

scale = 20

{{Out}}

=={{header|Beads}}==

calc main_init

var k = 0

loop reps:1000 count:n

k = k + 1/n^2

{{out}}

<pre>1.6439345666815615</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>

<code>√⁼</code> here reads as the inverse of the square root, which can be changed to <code>2⋆˜</code> or <code>ט</code>. It has been used here since it is the most intuitive.

=={{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|C++}}==

double f(double x);

{

return ( 1.0 / ( x * x ) );

=={{header|CLIPS}}==

(deffunction partial-sum-S

(?start ?stop)

)

(return ?sum)

Usage:

=={{header|Clojure}}==

=={{header|CLU}}==

fn: proctype (real) returns (real))

returns (real)

result: real := series_sum(1, 1000, one_over_k_squared)

stream$putl(po, f_form(result, 1, 6))

{{out}}

<pre>1.643935</pre>

=={{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|Crystal}}==

{{trans|Ruby}}

puts (1..5000).sum{ |x| 1.0 / x ** 2 }

puts (1..9999).sum{ |x| 1.0 / x ** 2 }

{{out}}

<pre>

=={{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|Dart}}==

{{trans|Scala}}

var list = new List<int>.generate(1000, (i) => i + 1);

});

print(sum);

{{trans|F#}}

if (x == 0)

return x;

main() {

print(f(1000));

=={{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|Dyalect}}==

{{trans|Swift}}

var ret = 0

var x = 1000

{{out}}

=={{header|E}}==

=={{header|EchoLisp}}==

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

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

(// (* PI PI) 6)

→ 1.6449340668482264

=={{header|EDSAC order code}}==

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.

[Sum of a series, Rosetta Code website.

EDSAC program, Initial Orders 2.]

[89] O5@ ZF [flush teleprinter buffer; stop]

E15Z PF [define entry point; enter with acc = 0]

{{out}}

<pre>

=={{header|Eiffel}}==

note

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

end

=={{header|Elena}}==

ELENA 4.x :

import extensions;

console.printLine:sum

{{out}}

<pre>

=={{header|Elixir}}==

=={{header|Emacs Lisp}}==

(when (<= n 0)

(user-error "n must be positive"))

(apply #'+ (mapcar (lambda (k) (/ 1.0 (* k k))) (number-sequence 1 n))))

=={{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|Excel}}==

{{Works with|Office 365 betas 2021}}

=LAMBDA(f,

LAMBDA(n,

=LAMBDA(n,

1 / (n ^ 2)

{{Out}}

=={{header|Ezhil}}==

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

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

=={{header|F_Sharp|F#}}==

The following function will do the task specified.

match x with

| 0. -> x

In the interactive F# console, using the above gives:

However, this recursive function will run out of stack space eventually (try 100000). A [[:Category:Recursion|tail-recursive]] implementation will not consume stack space and can therefore handle much larger ranges. Here is such a version:

let sum_series (max : float) =

let rec f (a:float, x : float) =

let (b, max) = System.Double.TryParse(args.[0])

printfn "%A" (sum_series max)

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:

Seq.sum [for x in [1..1000] do 1./(x * x |> float)]

=={{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|Fermat}}==

{{out}}

<pre>

=={{header|Fish}}==

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

Or in Fortran 77:

do i=1,1000

s=s+1./i**2

end do

write (*,*) s

=={{header|FreeBASIC}}==

Const pi As Double = 3.141592653589793

Print

Print "Press any key to quit"

{{out}}

=={{header|Frink}}==

Frink can calculate the series with exact rational numbers or floating-point values.

sum[map[{|k| 1/k^2}, 1 to 1000]]

{{out}}

<pre>

=={{header|GAP}}==

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

Approx(a, 10);

"1.6439345666"

=={{header|Genie}}==

/*

Sum of series, in Genie

Intl.setlocale()

print "ζ(2) approximation: %16.15f", sum_series(1, 1000, oneOverSquare)

{{out}}

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

or

or, as a single fold:

inverseSquare = (1 /) . (^ 2)

main :: IO ()

{{Out}}

<pre>1.6439345666815615</pre>

=={{header|Haxe}}==

===Procedural===

class Main {

Sys.println('Exact: '.lpad(' ', 15) + Math.PI * Math.PI / 6);

}

{{out}}

===Functional===

using StringTools;

Sys.println('Exact: '.lpad(' ', 15) + Math.PI * Math.PI / 6);

}

{{out}}

=={{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|Io}}==

=={{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}}==

===ES5===

var s = 0;

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

}

or, in a functional idiom:

function sum(fn, lstRange) {

);

{{Out}}

===ES6===

{{Trans|Haskell}}

'use strict';

return seriesSum(x => 1 / (x * x), enumFromTo(1, 1000));

{{Out}}

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

From Javascript ES5.

/* Sum of a series */

function sum(a:number, b:number , fn:function):number {

sum(1, 1000, function(x) { return 1/(x*x); } ) ==> 1.643934566681561

=!EXPECTEND!=

{{out}}

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|Kotlin}}==

fun main(args: Array<String>) {

println("Actual sum is $sum")

println("zeta(2) is ${Math.PI * Math.PI / 6.0}")

{{out}}

=={{header|Lambdatalk}}==

{+ {S.map {lambda {:k} {/ 1 {* :k :k}}} {S.serie 1 1000}}}

-> 1.6439345666815615 ~ 1.6449340668482264 = PI^2/6

=={{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|Lingo}}==

sum = 0

repeat with i = 1 to 1000

end repeat

put sum

=={{header|LiveCode}}==

add 1/(i^2) to summ

end repeat

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

=={{header|Maple}}==

{{Out|Output}}

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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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|min}}==

{{works with|min|0.19.3}}

((dup * 1 swap /) (id)) cleave

((+) (succ)) spread

{{out}}

<pre>

=={{header|MiniScript}}==

return 1 / num^2

end function

print sum(1, 1000, @zeta)

{{out}}

<pre>

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

=={{header|Modula-2}}==

FROM InOut IMPORT WriteLn;

FROM RealInOut IMPORT WriteReal;

WriteReal(seriesSum(1, 1000, oneOverKSquared), 10);

WriteLn;

{{out}}

<pre>1.6439E+00</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>

=={{header|NewLISP}}==

(for (i 1 1000)

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

=={{header|Nial}}==

=={{header|Nim}}==

for n in 1..1000: s += 1 / (n * n)

{{out}}

=={{header|Objeck}}==

bundle Default {

class SumSeries {

}

}