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

 

<pre>1.643934566681561</pre>

 

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

 

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

import extensions;

public program()

{

{{out}}

<pre>

 

=={{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|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|Fōrmulæ}}==

 

 

 

 

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

<pre>1.643934566681561</pre>

 

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

Output:

<pre>1.6439345666815615</pre>

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

type

tOutput = double;//extended;

writeln('The sum of 1/x^2 from 1 to 1000 is: ', Sum(1,1000,@f));

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

Output

<pre>different version of type and calculation

 

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

<span style="color: #008080;">function</span> <span style="color: #000000;">sumto</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">sumto</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|PHP}}==

 

/**

 

echo sum_of_a_series(1000,1);

{{out}}

<pre>1.6439345666816</pre>

 

=={{header|PicoLisp}}==

 

(let S 0

(for I 1000

(inc 'S (*/ 1.0 (* I I))) )

Output:

<pre>1.643935</pre>

 

=={{header|Pike}}==

`+(@(1.0/pow(x[*],2)[*]));

 

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

1 to 1000 (i): sum = sum + 1.0 / (i * i).

 

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

Or, as a generalised map, or fold / reduction – (see [[Catamorphism#Python]]):

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>The sum of a series:

 

=={{header|Q}}==

 

{{Out}}

Using the Quackery bignum rational arithmetic suite <code>bigrat.qky</code>.

 

 

[ 0 n->v rot times

say "As a decimal fraction, first 1000 places after the decimal point."

cr cr

 

{{out}}

 

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

In general, the <code>$n</code>th partial sum of a series whose terms are given by a unary function <code>&f</code> is

 

 

So what's needed in this case is

 

 

Or, using the "hyper" metaoperator to vectorize, we can use a more "point free" style while keeping traditional precedence:

 

Or we can use the <tt>X</tt> "cross" metaoperator, which is convenient even if one side or the other is a scalar. In this case, we demonstrate a scalar on either side:

 

Note that cross ops are parsed as list infix precedence rather than using the precedence of the base op as hypers do. Hence the difference in parenthesization.

 

With list comprehensions, you can write:

 

 

That's fine for a single result, but if you're going to be evaluating the sequence multiple times, you don't want to be recalculating the sum each time, so it's more efficient to define the sequence as a constant to let the run-time automatically cache those values already calculated. In a lazy language like Raku, it's generally considered a stronger abstraction to write the correct infinite sequence, and then take the part of it you're interested in.

Here we define an infinite sequence of partial sums (by adding a backslash into the reduction to make it look "triangular"), then take the 1000th term of that:

Note that infinite constant sequences can be lazily generated in Raku, or this wouldn't work so well...

 

A cleaner style is to combine these approaches with a more FP look:

 

 

Perhaps the cleanest way is to just define the zeta function and evaluate it for s=2, possibly using memoization:

sub ζ($s) is cached { [\+] 1..* X** -$s }

 

Notice how the thus-defined zeta function returns a lazy list of approximated values, which is arguably the closest we can get from the mathematical definition.

 

=={{header|Raven}}==

{{out}}

<pre>1.64393</pre>

 

=={{header|Red}}==

s: 0

repeat n 1000 [ s: 1.0 / n ** 2 + s ]

print s

 

=={{header|REXX}}==

===sums specific terms===

parse arg N D . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N=1000 /*Not specified? Then use the default.*/

end /*k*/

 

'''output''' &nbsp; when using the default input:

<pre>

===sums with running total===

This REXX version shows the &nbsp; ''running total'' &nbsp; for every 10^th term.

parse arg N D . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N=1000 /*Not specified? Then use the default.*/

say /*a blank line for sep. */

say 'The sum of' right(k-1,w) "terms is:" $ /*display the final sum.*/

'''output''' &nbsp; when using the input of: &nbsp; <tt> 1000000000 </tt>

<pre>

 

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''.

parse arg N D . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N=1000 /*Not specified? Then use the default.*/

say /*display blank line for the separator.*/

say 'The sum of' right(N,w) "terms is:" /*display the sum's preamble line. */

'''output''' &nbsp; when using the input of &nbsp; (one billion [limit], and one hundred decimal digits): &nbsp; <tt> &nbsp; 1000000000 &nbsp; 100 </tt>

<pre>

 

=={{header|Ring}}==

sum = 0

for i =1 to 1000

decimals(8)

see sum

 

=={{header|RLaB}}==

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

-0.000999500167

 

=={{header|Ruby}}==

{{out}}

<pre>

 

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

for i =1 to 1000

sum = sum + 1 /( i^2)

next i

 

=={{header|Rust}}==

const UPPER: i32 = 1000;

 

println!("{}", (LOWER..UPPER + 1).fold(0, |sum, x| sum + x));

}

 

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

 

Alternatively, using the ''reduce{}'' method:

 

{{out}}

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>

 

=={{header|Stata}}==

return(sum((n..1):^-2))

}

 

series(1000)-pi()^2/6

 

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

=== Using Expansion Operator and mathop ===

{{works with|Tcl|8.5}}

namespace path {::tcl::mathop ::tcl::} ;# Ease of access to mathop commands

proc lsum_series {l} {+ {*}[lmap n $l {/ [** $n 2]}]} ;# an expr would be clearer, but this is a demonstration of mathop

 

# using range function defined below

 

=== Using Loop ===

{{works with|Tcl|8.5}}

 

proc partial_sum {func - start - stop} {

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

 

 

=== Using tcllib ===

{{tcllib|struct::list}}

package require struct::list

 

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

 

 

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

proc range args {

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

}

return $range

 

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

{{trans|TI-89 BASIC}}

{{works with|TI-83 BASIC|TI-84Plus 2.55MP}}

∑(1/X²,X,1,1000)

{{out}}

<pre>

 

The TI-83 does not have the new summation notation, and caps lists at 999 entries.

{{out}}

<pre>

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

 

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

 

=={{header|VBA}}==

Dim res As Double

For i = 1 To n

Public Sub main()

Debug.Print sumto(1000)

<pre> 1,64393456668156 </pre>

 

=={{header|VBScript}}==

for i=1 to 1000

s=s+1/i^2

next

{{out}}

<pre>

{{trans|VBScript}}

{{works with|Visual Basic .NET|2013}}

Sub SumOfaSeries()

Dim s As Double

Next 'i

Console.WriteLine(s)

{{out}}

<pre>

1.64393456668156

</pre>

 

=={{header|WDTE}}==

 

s.range 1 1001

-> s.reduce 0 +

-- io.writeln io.stdout

 

{{out}}

 

=={{header|Wortel}}==

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

!* ; maps the number expression over the list

 

=={{header|Wren}}==

 

System.print("s(1000) = %(sumSeries.call(1000))")

 

{{out}}

 

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

 

=={{header|ZX Spectrum Basic}}==

20 LET s=0

30 FOR k=1 TO n

40 LET s=s+1/(k*k)

50 NEXT k

{{out}}

<pre>