Sum of a series: Difference between revisions
→{{header|langur}}
Not a robot (talk | contribs) (Add Modula-2) |
Langurmonkey (talk | contribs) |
||
(34 intermediate revisions by 23 users not shown) | |||
Line 21:
{{trans|Python}}
<
{{out}}
Line 29:
=={{header|360 Assembly}}==
<
SUMSER CSECT
USING SUMSER,12 base register
Line 52:
COPY FORMATF formatf code
PG DC CL80' ' buffer
END SUMSER</
{{out}}
<pre>
Line 59:
=={{header|ACL2}}==
<
(if (zp max-x)
0
(+ (/ (* max-x max-x))
(sum-x^-2 (1- max-x)))))</
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit
PROC Calc(CARD n REAL POINTER res)
CARD i,st
BYTE perc
REAL one,a,b
IntToReal(0,res)
IF n=0 THEN RETURN FI
IntToReal(1,one)
st=n/100
FOR i=1 TO n
DO
IF i MOD st=0 THEN
PrintB(perc) Put('%) PutE() Put(28)
perc==+1
FI
IntToReal(i,a)
RealMult(a,a,b)
RealDiv(one,b,a)
RealAdd(res,a,b)
RealAssign(b,res)
OD
RETURN
PROC Main()
REAL POINTER res
CARD n=[1000]
Put(125) PutE() ;clear screen
Calc(n,res)
PrintF("s(%U)=",n)
PrintRE(res)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_a_series.png Screenshot from Atari 8-bit computer]
<pre>
s(1000)=1.64392967
</pre>
=={{header|ActionScript}}==
<
{
var sum:Number = 0;
Line 73 ⟶ 117:
return sum;
}
trace(partialSum(1000));</
=={{header|Ada}}==
<
procedure Sum_Series is
Line 95 ⟶ 139:
Put(Item => Sum, Aft => 10, Exp => 0);
New_Line;
end Sum_Series;</
=={{header|Aime}}==
<
Invsqr(real n)
{
Line 122 ⟶ 166:
0;
}</
=={{header|ALGOL 68}}==
<
PROC sum = (PROC (INT)LONG REAL f, RANGE range)LONG REAL:(
Line 139 ⟶ 183:
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>
Line 147 ⟶ 191:
=={{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 %
Line 162 ⟶ 206:
end;
write( r_format := "A", r_w := 8, r_d := 5, sum( k, 1, 1000, 1 / ( k * k ) ) )
end.</
{{out}}
<pre>
Line 169 ⟶ 213:
=={{header|APL}}==
<
1.64393</
=={{header|AppleScript}}==
{{Trans|JavaScript}}
{{Trans|Haskell}}
<
-- seriesSum :: Num a => (a -> a) -> [a] -> a
Line 243 ⟶ 287:
end script
end if
end mReturn</
{{Out}}
<syntaxhighlight lang
=={{header|Arturo}}==
<
print [sum series]</
{{out}}
<pre>1.643934566681561</pre>
=={{header|Asymptote}}==
<syntaxhighlight lang="Asymptote">real sum;
for(int i = 1; i < 1000; ++i) sum = sum + 1 / (i * i);
write(sum, suffix=none);</syntaxhighlight>
{{out}}
<pre>1.64393356668156</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
MsgBox,% sum ;1.643934566681554</
=={{header|AWK}}==
<
1.64393</
=={{header|BASIC}}==
{{works with|QuickBasic|4.5}}
<
s = 1 / x ^ 2
end function
Line 279 ⟶ 330:
sum = ret
end function
print sum(1, 1000)</
==={{header|BASIC256}}===
{{works with|True BASIC}}
<syntaxhighlight lang="basic256">
function sumSeries(n)
if n = 0 then sumSeries = 0
Line 296 ⟶ 347:
print "zeta(2) = "; pi * pi / 6
end
</syntaxhighlight>
==={{header|BBC BASIC}}===
<
sum += 1/i%^2
NEXT
PRINT sum</
==={{header|Gambas}}===
<syntaxhighlight lang="vbnet">Public Sub Main()
Print "s(1000) = "; sumSeries(1000)
Print "zeta(2) = "; Pi * Pi / 6
End
Function sumSeries(n As Integer) As Float
If n = 0 Then Return 0
Dim sum As Float = 0
For k As Integer = 1 To n
sum += 1.0 / (k * k)
Next
Return sum
End Function</syntaxhighlight>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FUNCTION sumSeries# (n)
IF n = 0 THEN sunSeries = 0
FOR k = 1 TO n
sum# = sum# + 1! / (k * k)
NEXT
sumSeries# = sum#
END FUNCTION
pi# = 4 * ATN(1)
PRINT "s(1000) = "; sumSeries#(1000)
PRINT "zeta(2) = "; pi# * pi# / 6
END</syntaxhighlight>
==={{header|True BASIC}}===
{{works with|BASIC256}}
<
FUNCTION sumSeries(n)
IF n = 0 then
Line 321 ⟶ 407:
PRINT "zeta(2) = "; pi * pi / 6
END
</syntaxhighlight>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "SumOfASeries"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
DECLARE FUNCTION sumSeries#(n)
FUNCTION Entry ()
pi# = 3.1415926535896
PRINT "s(1000) = "; sumSeries#(1000)
PRINT "zeta(2) = "; pi# * pi# / 6
END FUNCTION
FUNCTION sumSeries#(n)
IF n = 0 THEN RETURN 0
sum# = 0
FOR k = 1 TO n
sum# = sum# + 1.0/(k * k)
NEXT
RETURN sum#
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|Yabasic}}===
<
sub sumSeries(n)
if n = 0 then return 0 : fi
Line 337 ⟶ 450:
print "zeta(2) = ", pi * pi / 6
end
</syntaxhighlight>
=={{header|bc}}==
<
return(1 / (x * x))
}
Line 355 ⟶ 468:
scale = 20
s(1000)</
{{Out}}
Line 361 ⟶ 474:
=={{header|Beads}}==
<
calc main_init
var k = 0
loop reps:1000 count:n
k = k + 1/n^2
log to_str(k)</
{{out}}
<pre>1.6439345666815615</pre>
Line 372 ⟶ 485:
=={{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/**
"."\55+%68^>\55+/00g1-:#^_$</
{{out}}
<pre>1.643934</pre>
=={{header|BQN}}==
<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.
<syntaxhighlight lang="bqn"> +´÷√⁼1+↕1000
1.6439345666815597</syntaxhighlight>
=={{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)
Line 391 ⟶ 511:
=={{header|Brat}}==
<
=={{header|C}}==
<
double Invsqr(double n)
Line 412 ⟶ 532:
return 0;
}</
=={{header|C sharp|C#}}==
<
{
static void Main(string[] args)
Line 433 ⟶ 553:
Console.ReadLine();
}
}</
An alternative approach using Enumerable.Range() to generate the numbers.
<
{
static void Main(string[] args)
Line 446 ⟶ 566:
Console.ReadLine();
}
}</
=={{header|C++}}==
<
double f(double x);
Line 471 ⟶ 591:
{
return ( 1.0 / ( x * x ) );
}</
=={{header|CLIPS}}==
<
(deffunction partial-sum-S
(?start ?stop)
Line 482 ⟶ 602:
)
(return ?sum)
)</
Usage:
Line 489 ⟶ 609:
=={{header|Clojure}}==
<
=={{header|CLU}}==
<syntaxhighlight lang="clu">series_sum = proc (from, to: int,
fn: proctype (real) returns (real))
returns (real)
sum: real := 0.0
for i: int in int$from_to(from, to) do
sum := sum + fn(real$i2r(i))
end
return(sum)
end series_sum
one_over_k_squared = proc (k: real) returns (real)
return(1.0 / (k * k))
end one_over_k_squared
start_up = proc ()
po: stream := stream$primary_output()
result: real := series_sum(1, 1000, one_over_k_squared)
stream$putl(po, f_form(result, 1, 6))
end start_up</syntaxhighlight>
{{out}}
<pre>1.643935</pre>
=={{header|COBOL}}==
<
PROGRAM-ID. sum-of-series.
Line 510 ⟶ 653:
GOBACK
.</
{{out}}
<pre>
Line 517 ⟶ 660:
=={{header|CoffeeScript}}==
<syntaxhighlight lang="coffeescript">
console.log [1..1000].reduce((acc, x) -> acc + (1.0 / (x*x)))
</syntaxhighlight>
=={{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 }
puts Math::PI ** 2 / 6</
{{out}}
<pre>
Line 540 ⟶ 683:
=={{header|D}}==
===More Procedural Style===
<
ReturnType!TF series(TF)(TF func, int end, int start=1)
Line 552 ⟶ 695:
void main() {
writeln("Sum: ", series((in int n) => 1.0L / (n ^^ 2), 1_000));
}</
{{out}}
<pre>Sum: 1.64393</pre>
Line 558 ⟶ 701:
===More functional Style===
Same output.
<
enum series(alias F) = (in int end, in int start=1)
Line 565 ⟶ 708:
void main() {
writeln("Sum: ", series!q{1.0L / (a ^^ 2)}(1_000));
}</
=={{header|dc}}==
<syntaxhighlight lang="dc">20 k 0 [ln 1 + d sn _2 ^ + 1000 ln <l] d sl x p</syntaxhighlight>
{{out}}
<pre>1.64393456668155979824</pre>
=={{header|Dart}}==
{{trans|Scala}}
<
var list = new List<int>.generate(1000, (i) => i + 1);
Line 578 ⟶ 726:
});
print(sum);
}</
{{trans|F#}}
<
if (x == 0)
return x;
Line 590 ⟶ 738:
main() {
print(f(1000));
}</
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">
unit Form_SumOfASeries_Unit;
Line 641 ⟶ 789:
end.
</syntaxhighlight>
{{out}}
<pre>1.64393456668156</pre>
Line 647 ⟶ 795:
=={{header|DWScript}}==
<
var s : Float;
for var i := 1 to 1000 do
Line 653 ⟶ 801:
PrintLn(s);
</syntaxhighlight>
=={{header|Dyalect}}==
Line 659 ⟶ 807:
{{trans|Swift}}
<
var ret = 0
Line 670 ⟶ 818:
var x = 1000
print(x.
{{out}}
Line 678 ⟶ 826:
=={{header|E}}==
<
accum 0 for x in 1..1000 { _ + 1 / x ** 2 }</
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
numfmt 8 0
for i = 1 to 1000
s += 1 / (i * i)
.
print s
</syntaxhighlight>
=={{header|EchoLisp}}==
<
(lib 'math) ;; for (sigma f(n) nfrom nto) function
(Σ (λ(n) (// (* n n))) 1 1000)
Line 691 ⟶ 848:
(// (* PI PI) 6)
→ 1.6449340668482264
</syntaxhighlight>
=={{header|EDSAC order code}}==
Line 697 ⟶ 854:
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.]
Line 760 ⟶ 917:
[89] O5@ ZF [flush teleprinter buffer; stop]
E15Z PF [define entry point; enter with acc = 0]
</syntaxhighlight>
{{out}}
<pre>
Line 768 ⟶ 925:
=={{header|Eiffel}}==
<
note
description: "Compute the n-th term of a series"
Line 820 ⟶ 977:
end
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
import extensions;
public program()
{
var sum := new Range(1, 1000).selectBy::(x => 1.0r / (x * x)).summarize(new Real());
console.printLine
}</
{{out}}
<pre>
Line 839 ⟶ 996:
=={{header|Elixir}}==
<
1.6439345666815615</
=={{header|Elm}}==
<
module Main exposing (main)
import Html exposing (h1, div, p, text)
import Html.Attributes exposing (style)
aList : List Int
aList = List.range 1 1000
-- version a with a list
k2xSum : Float
k2xSum = List.sum
<| List.map (\x -> 1.0 / x / x )
<| List.map (\n -> toFloat n) aList
-- version b with a list
fx : Int -> Float
fx =
(\n -> toFloat n |> \m -> 1.0 / m / m)
f2kSum : Float
f2kSum = List.sum
<| List.map fx aList
-- version with recursion, without a list
untilMax : Int -> Int -> Float -> Float
untilMax k kmax accum =
if k > kmax
then accum
else
let
x = toFloat k
dx = 1.0 / x / x
in untilMax (k + 1) kmax (accum + dx)
recSum : Float
recSum = untilMax 1 1000 0.0
main = div [style "margin" "5%", style "color" "blue"] [
h1 [] [text "Sum of series Σ 1/k²"]
, text (" Version a with a list: Sum = " ++ String.fromFloat k2xSum)
, p [] [text (" Version b with a list: Sum = " ++ String.fromFloat f2kSum)]
, p [] [text (" Recursion version c: Sum = " ++ String.fromFloat recSum)]
]
</syntaxhighlight>
{{Out}}
<pre>
Sum of series Σ 1/k²
Version a with a list: Sum = 1.6439345666815615
Version b with a list: Sum = 1.6439345666815615
Recursion version c: Sum = 1.6439345666815615
</pre>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(defun series (n)
(when (<= n 0)
(user-error "n must be positive"))
(apply #'+ (mapcar (lambda (k) (/ 1.0 (* k k))) (number-sequence 1 n))))
(format "%.10f" (series 1000)) ;=> "1.6439345667"</syntaxhighlight>
=={{header|Erlang}}==
<
=={{header|Euphoria}}==
{{works with|Euphoria|4.0.0}}
This is based on the [[BASIC]] example.
<syntaxhighlight lang="euphoria">
function s( atom x )
return 1 / power( x, 2 )
Line 876 ⟶ 1,087:
end function
printf( 1, "%.15f\n", sum( 1, 1000 ) )</
=={{header|Excel}}==
Line 888 ⟶ 1,099:
{{Works with|Office 365 betas 2021}}
<
=LAMBDA(f,
LAMBDA(n,
Line 901 ⟶ 1,112:
=LAMBDA(n,
1 / (n ^ 2)
)</
{{Out}}
Line 935 ⟶ 1,146:
=={{header|Ezhil}}==
<syntaxhighlight lang="ezhil">
## இந்த நிரல் தொடர் கூட்டல் (Sum Of Series) என்ற வகையைச் சேர்ந்தது
Line 961 ⟶ 1,172:
பதிப்பி "அதன் தொடர்க் கூட்டல் " தொடர்க்கூட்டல்(அ)
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
The following function will do the task specified.
<
match x with
| 0. -> x
| x -> (1. / (x * x)) + f (x - 1.)</
In the interactive F# console, using the above gives:
<
val it : float = 1.643934567</
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) =
Line 985 ⟶ 1,196:
let (b, max) = System.Double.TryParse(args.[0])
printfn "%A" (sum_series max)
0</
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)]
</syntaxhighlight>
=={{header|Factor}}==
<
=={{header|Fantom}}==
Line 1,000 ⟶ 1,211:
Within 'fansh':
<
fansh> (1..1000).toList.reduce(0.0f) |Obj a, Int v -> Obj| { (Float)a + (1.0f/(v*v)) }
1.6439345666815615
</syntaxhighlight>
=={{header|Fermat}}==
<
{{out}}
<pre>
Line 1,027 ⟶ 1,238:
=={{header|Fish}}==
<
;n&^?:-1&+ <</
=={{header|Forth}}==
<
0e
bounds do
Line 1,039 ⟶ 1,250:
:noname ( x -- 1/x^2 ) fdup f* 1/f ; ( xt )
1 1000 sum f. \ 1.64393456668156
pi pi f* 6e f/ f. \ 1.64493406684823</
=={{header|Fortran}}==
In ISO Fortran 90 and later, use SUM intrinsic:
<
real :: result
result = sum(a);</
Or in Fortran 77:
<
do i=1,1000
s=s+1./i**2
end do
write (*,*) s
end</
=={{header|FreeBASIC}}==
<
Const pi As Double = 3.141592653589793
Line 1,073 ⟶ 1,284:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 1,083 ⟶ 1,294:
=={{header|Frink}}==
Frink can calculate the series with exact rational numbers or floating-point values.
<
sum[map[{|k| 1/k^2}, 1 to 1000]]
</syntaxhighlight>
{{out}}
<pre>
Line 1,094 ⟶ 1,305:
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sum_of_a_series}}
'''Solution'''
In the following function, the first parameter is the series is provided as a lambda expression. The second parameter is the number of terms to calculate
[[File:Fōrmulæ - Sum of a series 01.png]]
'''Test case'''
The exact value (of the sum) is:
[[File:Fōrmulæ - Sum of a series 02.png]]
(click to enlarge)
[[File:Fōrmulæ - Sum of a series 03.png|750px||link=https://static.wikiforge.net/rosettacodewikitide/0/0f/F%C5%8Drmul%C3%A6_-_Sum_of_a_series_03.png]]
The approximate value is:
[[File:Fōrmulæ - Sum of a series 04.png]]
[[File:Fōrmulæ - Sum of a series 05.png]]
While the (approximate) value of π<sup>2</sup>/6 is:
[[File:Fōrmulæ - Sum of a series 06.png]]
[[File:Fōrmulæ - Sum of a series 07.png]]
=={{header|GAP}}==
<
# Computing an approximation of a rationnal (giving a string)
Line 1,132 ⟶ 1,367:
Approx(a, 10);
"1.6439345666"
# and pi^2/6 is 1.6449340668, truncated to ten digits</
=={{header|Genie}}==
<
/*
Sum of series, in Genie
Line 1,156 ⟶ 1,391:
Intl.setlocale()
print "ζ(2) approximation: %16.15f", sum_series(1, 1000, oneOverSquare)
print "π² / 6 : %16.15f", Math.PI * Math.PI / 6.0</
{{out}}
Line 1,165 ⟶ 1,400:
=={{header|GEORGE}}==
<syntaxhighlight lang="george">
0 (s)
1, 1000 rep (i)
Line 1,171 ⟶ 1,406:
]
P
</syntaxhighlight>
Output:-
<pre>
Line 1,178 ⟶ 1,413:
=={{header|Go}}==
<
import ("fmt"; "math")
Line 1,189 ⟶ 1,424:
}
fmt.Println("computed:", sum)
}</
Output:
<pre>known: 1.6449340668482264
Line 1,196 ⟶ 1,431:
=={{header|Groovy}}==
Start with smallest terms first to minimize rounding error:
<
Output:
Line 1,203 ⟶ 1,438:
=={{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 ()
main = print $ seriesSum inverseSquare [1 .. 1000]</
{{Out}}
<pre>1.6439345666815615</pre>
Line 1,224 ⟶ 1,459:
=={{header|Haxe}}==
===Procedural===
<
class Main {
Line 1,234 ⟶ 1,469:
Sys.println('Exact: '.lpad(' ', 15) + Math.PI * Math.PI / 6);
}
}</
{{out}}
Line 1,243 ⟶ 1,478:
===Functional===
<
using StringTools;
Line 1,252 ⟶ 1,487:
Sys.println('Exact: '.lpad(' ', 15) + Math.PI * Math.PI / 6);
}
}</
{{out}}
Line 1,258 ⟶ 1,493:
=={{header|HicEst}}==
<
a = 1 / $^2
WRITE(ClipBoard, Format='F17.15') SUM(a) </
<syntaxhighlight lang
=={{header|Icon}} and {{header|Unicon}}==
<
local i, sum
sum := 0 & i := 0
every sum +:= 1.0/((| i +:= 1 ) ^ 2) \1000
write(sum)
end</
or
<
every (sum := 0) +:= 1.0/((1 to 1000)^2)
write(sum)
end</
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 +:=
</syntaxhighlight>
=={{header|IDL}}==
<
=={{header|Io}}==
Line 1,299 ⟶ 1,534:
=={{header|J}}==
<
+/ % *: >: i. 1000
1.64393
Line 1,307 ⟶ 1,542:
1r6p2 NB. As a constant (J has a rich constant notation)
1.64493</
=={{header|Java}}==
<
public static double f(double x){
return 1/(x*x);
Line 1,324 ⟶ 1,559:
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);
Line 1,334 ⟶ 1,569:
}
sum(1,1000, function(x) { return 1/(x*x) } ) // 1.64393456668156</
or, in a functional idiom:
<
function sum(fn, lstRange) {
Line 1,362 ⟶ 1,597:
);
})();</
{{Out}}
<syntaxhighlight lang
===ES6===
{{Trans|Haskell}}
<
'use strict';
Line 1,394 ⟶ 1,629:
return seriesSum(x => 1 / (x * x), enumFromTo(1, 1000));
})();</
{{Out}}
<syntaxhighlight lang
=={{header|Joy}}==
<syntaxhighlight lang="joy">1000 [0] [swap -2 pow +] primrec.</syntaxhighlight>
{{out}}
<pre>1.64393</pre>
=={{header|jq}}==
Line 1,402 ⟶ 1,642:
Directly:
<
s(1000)
</syntaxhighlight>
{{Out}}
1.6439345666815615
Line 1,411 ⟶ 1,651:
Using a generic summation wrapper function allows problems specified in "sigma" notation to be solved using syntax that closely resembles that notation:
<
summation( range(1; 1001) | (1/(. * .) ) )</
An important point is that nothing is lost in efficiency using the declarative and quite elegant approach using "summation".
Line 1,420 ⟶ 1,660:
From Javascript ES5.
<
/* Sum of a series */
function sum(a:number, b:number , fn:function):number {
Line 1,434 ⟶ 1,674:
sum(1, 1000, function(x) { return 1/(x*x); } ) ==> 1.643934566681561
=!EXPECTEND!=
*/</
{{out}}
Line 1,443 ⟶ 1,683:
Using a higher-order function:
<
1.643934566681559
julia> pi^2/6
1.6449340668482264
</syntaxhighlight>
A simple loop is more optimized:
<
s = 0.0
for k = 1:n
Line 1,461 ⟶ 1,701:
julia> f(1000)
1.6439345666815615</
=={{header|K}}==
<
ssr 1+!1000
1.643935</
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
Line 1,476 ⟶ 1,716:
println("Actual sum is $sum")
println("zeta(2) is ${Math.PI * Math.PI / 6.0}")
}</
{{out}}
Line 1,485 ⟶ 1,725:
=={{header|Lambdatalk}}==
<
{+ {S.map {lambda {:k} {/ 1 {* :k :k}}} {S.serie 1 1000}}}
-> 1.6439345666815615 ~ 1.6449340668482264 = PI^2/6
</syntaxhighlight>
=={{header|Lang5}}==
<
=={{header|langur}}==
<syntaxhighlight lang="langur">writeln "calc.: ", fold fn{+}, map fn(.x) { 1/.x^2 }, 1..1000
writeln "known: ", pi^2/6</syntaxhighlight>
{{out}}
<pre>calc.: 1.643934566681559803139058023822206
exact: 1.644934066848226436472415166646025
</pre>
If we set a higher arbitrary maximum for division, we get more digits.
<syntaxhighlight lang="langur">mode divMaxScale = 100
writeln "calc.: ", fold fn{+}, map fn(.x) 1/.x^2, 1..1000
writeln "known: ", pi^2/6</syntaxhighlight>
{{out}}
<pre>calc.: 1.6439345666815598031390580238222155896521034464936853167172372054281147052136371544864376381235947140
exact: 1.6449340668482264364724151666460251892189499012067984377355582293700074704032008738336289006197587053
</pre>
=={{header|Lasso}}==
<
local(sum = 0)
loop(-from=#k,-to=#n) => {
Line 1,501 ⟶ 1,762:
return #sum
}
sum_of_a_series(1000,1)</
{{out}}
<pre>1.643935</pre>
Line 1,509 ⟶ 1,770:
=== With <code>lists:foldl</code> ===
<
(defun sum-series (nums)
(lists:foldl
Line 1,517 ⟶ 1,778:
(lambda (x) (/ 1 x x))
nums)))
</syntaxhighlight>
=== With <code>lists:sum</code> ===
<
(defun sum-series (nums)
(lists:sum
Line 1,527 ⟶ 1,788:
(lambda (x) (/ 1 x x))
nums)))
</syntaxhighlight>
Both have the same result:
<
> (sum-series (lists:seq 1 100000))
1.6449240668982423
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
for i =1 to 1000
sum =sum +1 /( i^2)
Line 1,545 ⟶ 1,806:
end
</syntaxhighlight>
=={{header|Lingo}}==
<
sum = 0
repeat with i = 1 to 1000
Line 1,554 ⟶ 1,815:
end repeat
put sum
-- 1.64393457</
=={{header|LiveCode}}==
<
add 1/(i^2) to summ
end repeat
put summ //1.643935</
=={{header|Logo}}==
<
localmake "sigma 0
for [i :a :b] [make "sigma :sigma + invoke :fn :i]
Line 1,573 ⟶ 1,834:
print series "zeta.2 1 1000
make "pi (radarctan 0 1) * 2
print :pi * :pi / 6</
=={{header|Lua}}==
<
sum = 0
for i = 1, 1000 do sum = sum + 1/i^2 end
print(sum)
</syntaxhighlight>
=={{header|Lucid}}==
<
where
num = 1 fby num + 1;
ssum = ssum + 1/(num * num)
end;</
=={{header|Maple}}==
<
{{Out|Output}}
<pre>-Psi(1, 1001)+(1/6)*Pi^2</pre>
Line 1,596 ⟶ 1,857:
=={{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}]
Plus@@Table[1./x^2, {x, 1, 1000}]</
=={{header|MATLAB}}==
<
=={{header|Maxima}}==
<
835459384831496894781878542648[806 digits]396236858699094240207812766449
(%o45) ------------------------------------------------------------------------
Line 1,620 ⟶ 1,881:
(%i46) sum(1/x^2, x, 1, 1000),numer;
(%o46) 1.643934566681561</
=={{header|MAXScript}}==
<
for i in 1 to 1000 do
(
total += 1.0 / pow i 2
)
print total</
=={{header|min}}==
{{works with|min|0.19.3}}
<
((dup * 1 swap /) (id)) cleave
((+) (succ)) spread
) 1000 times pop print</
{{out}}
<pre>
Line 1,642 ⟶ 1,903:
=={{header|MiniScript}}==
<
return 1 / num^2
end function
Line 1,655 ⟶ 1,916:
print sum(1, 1000, @zeta)
</syntaxhighlight>
{{out}}
<pre>
Line 1,662 ⟶ 1,923:
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">0 П0 П1 ИП1 1 + П1 x^2 1/x ИП0
+ П0 ИП1 1 0 0 0 - x>=0 03
ИП0 С/П</
=={{header|ML}}==
==={{header|Standard ML}}===
<syntaxhighlight lang="standard ml">
(* 1.64393456668 *)
List.foldl op+ 0.0 (List.tabulate(1000, fn x => 1.0 / Math.pow(real(x + 1),2.0)))
</syntaxhighlight>
==={{header|mLite}}===
<
Output:
<pre>1.6439345666815549</pre>
=={{header|MMIX}}==
<
y IS $2 % id
z IS $3 % z = sum series
Line 1,785 ⟶ 2,046:
PBNP t,1B } z = sum
GO $127,prtFlt print sum --> StdOut
TRAP 0,Halt,0</
Output:
<pre>~/MIX/MMIX/Rosetta> mmix sumseries
Line 1,791 ⟶ 2,052:
=={{header|Modula-2}}==
<
FROM InOut IMPORT WriteLn;
FROM RealInOut IMPORT WriteReal;
Line 1,816 ⟶ 2,077:
WriteReal(seriesSum(1, 1000, oneOverKSquared), 10);
WriteLn;
END SeriesSum.</
{{out}}
<pre>1.6439E+00</pre>
Line 1,822 ⟶ 2,083:
=={{header|Modula-3}}==
Modula-3 uses D0 after a floating point number as a literal for <tt>LONGREAL</tt>.
<
IMPORT IO, Fmt, Math;
Line 1,840 ⟶ 2,101:
IO.Put(Fmt.LongReal(sum));
IO.Put("\n");
END Sum.</
Output:
<pre>
Line 1,847 ⟶ 2,108:
=={{header|MUMPS}}==
<syntaxhighlight lang="mumps">
SOAS(N)
NEW SUM,I SET SUM=0
Line 1,853 ⟶ 2,114:
.SET SUM=SUM+(1/((I*I)))
QUIT SUM
</syntaxhighlight>
This is an extrinsic function so the usage is:
<pre>
Line 1,861 ⟶ 2,122:
=={{header|NewLISP}}==
<
(for (i 1 1000)
(inc s (div 1 (* i i))))
(println s))</
=={{header|Nial}}==
<
=1.64393</
=={{header|Nim}}==
<
for n in 1..1000: s += 1 / (n * n)
echo s</
{{out}}
<pre>1.643934566681561</pre>
=={{header|Oberon-2}}==
{{trans|Modula-2}}
<syntaxhighlight lang="oberon2">MODULE SS;
IMPORT Out;
TYPE
RealFunc = PROCEDURE(r:REAL):REAL;
PROCEDURE SeriesSum(k,n:LONGINT;f:RealFunc):REAL;
VAR
total:REAL;
i:LONGINT;
BEGIN
total := 0.0;
FOR i := k TO n DO total := total + f(i) END;
RETURN total
END SeriesSum;
PROCEDURE OneOverKSquared(k:REAL):REAL;
BEGIN RETURN 1.0 / (k * k)
END OneOverKSquared;
BEGIN
Out.Real(SeriesSum(1,1000,OneOverKSquared),10);
Out.Ln;
END SS.
</syntaxhighlight>
{{out}}
<pre>1.64393E+00
</pre>
=={{header|Objeck}}==
<
bundle Default {
class SumSeries {
Line 1,904 ⟶ 2,198:
}
}
</syntaxhighlight>
=={{header|OCaml}}==
<
let result = ref 0. in
for i = a to b do
result := !result +. fn i
done;
!result</
# sum 1 1000 (fun x -> 1. /. (float x ** 2.))
Line 1,918 ⟶ 2,212:
or in a functional programming style:
<
let rec aux i r =
if i > b then r
Line 1,924 ⟶ 2,218:
in
aux a 0.
;;</
Simple recursive solution:
<
in sum 1000</
=={{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}}
Line 1,950 ⟶ 2,244:
Conventionally like elsewhere:
<
def var n as int no-undo.
Line 1,957 ⟶ 2,251:
end.
display dcResult .</
or like this:
<
repeat n = 1 to 1000 :
Line 1,967 ⟶ 2,261:
end.
display ( accum total 1 / (n * n) ) .</
=={{header|Oz}}==
With higher-order functions:
<
fun {SumSeries S N}
{FoldL {Map {List.number 1 N 1} S}
Line 1,981 ⟶ 2,275:
end
in
{Show {SumSeries S 1000}}</
Iterative:
<
R = {NewCell 0.}
in
Line 1,991 ⟶ 2,285:
end
@R
end</
=={{header|Panda}}==
<
Output:
<pre>1.6439345666815615</pre>
Line 2,000 ⟶ 2,294:
=={{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
<syntaxhighlight lang
=={{header|Pascal}}==
<
type
tOutput = double;//extended;
Line 2,034 ⟶ 2,328:
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);
end.</
Output
<pre>different version of type and calculation
Line 2,047 ⟶ 2,341:
=={{header|Perl}}==
<
$sum += 1 / $_ ** 2 foreach 1..1000;
print "$sum\n";</
or
<
$sum = reduce { $a + 1 / $b ** 2 } 0, 1..1000;
print "$sum\n";</
An other way of doing it is to define the series as a closure:
<
my @S = map &$S, 1 .. 1000;
print $S[-1];</
=={{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>
Line 2,069 ⟶ 2,363:
<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>
Line 2,076 ⟶ 2,370:
=={{header|PHP}}==
<
/**
Line 2,098 ⟶ 2,392:
echo sum_of_a_series(1000,1);
</syntaxhighlight>
{{out}}
<pre>1.6439345666816</pre>
=={{header|Picat}}==
===List comprehension===
<syntaxhighlight lang="picat">s(N) = sum([1.0/K**2 : K in 1..N]).</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="picat">s2(N) = Sum =>
K = 1,
Sum1 = 0,
while(K <= N)
Sum1 := Sum1 + 1/K**2,
K := K + 1
end,
Sum = Sum1.</syntaxhighlight>
===Test===
<syntaxhighlight lang="picat">go =>
% List comprehension
test(s,1000),
nl,
% Iterative
test(s2,1000),
nl.
test(Fun,N) =>
println([fun=Fun,n=N]),
Pi2_6 = math.pi**2/6,
println(Pi2_6='math.pi**2/6'),
nl,
foreach(I in 1..6)
S = apply(Fun,10**I),
printf("%f (diff: %w)\n", S,Pi2_6-S)
end,
nl.</syntaxhighlight>
{{out}}
<pre>[fun = s,n = 1000]
1.644934066848226 = math.pi**2/6
1.549768 (diff: 0.095166335681686)
1.634984 (diff: 0.009950166663334)
1.643935 (diff: 0.000999500166665)
1.644834 (diff: 0.000099995000161)
1.644924 (diff: 0.000009999949984)
1.644933 (diff: 0.000000999999456)
[fun = s2,n = 1000]
1.644934066848226 = math.pi**2/6
1.549768 (diff: 0.095166335681686)
1.634984 (diff: 0.009950166663334)
1.643935 (diff: 0.000999500166665)
1.644834 (diff: 0.000099995000161)
1.644924 (diff: 0.000009999949984)
1.644933 (diff: 0.000000999999456)</pre>
=={{header|PicoLisp}}==
<
(let S 0
(for I 1000
(inc 'S (*/ 1.0 (* I I))) )
(prinl (round S 6)) ) # Round result to 6 digits</
Output:
<pre>1.643935</pre>
=={{header|Pike}}==
<
`+(@(1.0/pow(x[*],2)[*]));
Result: 1.64393</
=={{header|PL/I}}==
<
s = 0;
Line 2,125 ⟶ 2,474:
end;
put skip list (s);</
{{out}}
Line 2,134 ⟶ 2,483:
=={{header|Pop11}}==
<
for j from 1 to 1000 do
s + 1.0/(j*j) -> s;
endfor;
s =></
=={{header|PostScript}}==
<syntaxhighlight lang="text">
/aproxriemann{
/x exch def
Line 2,155 ⟶ 2,504:
1000 aproxriemann
</syntaxhighlight>
Output:
<syntaxhighlight lang="text">
1.64393485
</syntaxhighlight>
{{libheader|initlib}}
<
% using map
[1 1000] 1 range {dup * 1 exch div} map 0 {+} fold
Line 2,168 ⟶ 2,517:
% just using fold
[1 1000] 1 range 0 {dup * 1 exch div +} fold
</syntaxhighlight>
=={{header|Potion}}==
<
1 to 1000 (i): sum = sum + 1.0 / (i * i).
sum print</
=={{header|PowerShell}}==
<
| ForEach-Object { 1 / ($_ * $_) } `
| Measure-Object -Sum
Write-Host Sum = $x.Sum</
=={{header|Prolog}}==
Works with SWI-Prolog.
<
findall(L, (between(1,1000,N),L is 1/N^2), Ls),
sumlist(Ls, S).
</syntaxhighlight>
Ouptput :
<pre>?- sum(S).
Line 2,193 ⟶ 2,542:
=={{header|PureBasic}}==
<
For i=1 To 1000
Line 2,199 ⟶ 2,548:
Next i
Debug sum</
<tt>
Answer = 1.6439345666815615
Line 2,205 ⟶ 2,554:
=={{header|Python}}==
<
Or, as a generalised map, or fold / reduction – (see [[Catamorphism#Python]]):
<
from functools import reduce
Line 2,280 ⟶ 2,629:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>The sum of a series:
Line 2,288 ⟶ 2,637:
=={{header|Q}}==
<
sn 1000</
{{Out}}
Line 2,298 ⟶ 2,647:
Using the Quackery bignum rational arithmetic suite <code>bigrat.qky</code>.
<
[ 0 n->v rot times
Line 2,315 ⟶ 2,664:
say "As a decimal fraction, first 1000 places after the decimal point."
cr cr
1000 point$ echo$</
{{out}}
Line 2,330 ⟶ 2,679:
=={{header|R}}==
<
=={{header|Racket}}==
Line 2,336 ⟶ 2,685:
A solution using Typed Racket:
<
#lang typed/racket
Line 2,343 ⟶ 2,692:
(for/sum: : Real ([k : Natural (in-range 1 (+ n 1))])
(/ 1.0 (* k k))))
</syntaxhighlight>
=={{header|Raku}}==
Line 2,351 ⟶ 2,700:
In general, the <code>$n</code>th partial sum of a series whose terms are given by a unary function <code>&f</code> is
<syntaxhighlight lang="raku"
So what's needed in this case is
<syntaxhighlight lang="raku"
Or, using the "hyper" metaoperator to vectorize, we can use a more "point free" style while keeping traditional precedence:
<syntaxhighlight lang="raku"
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:
<syntaxhighlight lang="raku"
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:
<syntaxhighlight lang="raku"
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:
<syntaxhighlight lang="raku"
say @x[1000]; # prints 1.64393456668156</
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:
<syntaxhighlight lang="raku"
say ζish[1000];</
Perhaps the cleanest way is to just define the zeta function and evaluate it for s=2, possibly using memoization:
<syntaxhighlight lang="raku"
sub ζ($s) is cached { [\+] 1..* X** -$s }
say ζ(2)[1000];</
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}}==
<
"%g\n" print</
{{out}}
<pre>1.64393</pre>
Line 2,395 ⟶ 2,744:
=={{header|Red}}==
<
s: 0
repeat n 1000 [ s: 1.0 / n ** 2 + s ]
print s
</syntaxhighlight>
=={{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.*/
Line 2,413 ⟶ 2,762:
end /*k*/
say 'The sum of' N "terms is:" $ /*stick a fork in it, we're all done. */</
'''output''' when using the default input:
<pre>
Line 2,421 ⟶ 2,770:
===sums with running total===
This REXX version shows the ''running total'' for every 10<sup>th</sup> term.
<
parse arg N D . /*obtain optional arguments from the CL*/
if N=='' | N=="," then N=1000 /*Not specified? Then use the default.*/
Line 2,439 ⟶ 2,788:
say /*a blank line for sep. */
say 'The sum of' right(k-1,w) "terms is:" $ /*display the final sum.*/
/*stick a fork in it, we're all done. */</
'''output''' when using the input of: <tt> 1000000000 </tt>
<pre>
Line 2,462 ⟶ 2,811:
If the '''old''' REXX variable would be set to '''1.64''' (instead of '''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.*/
Line 2,482 ⟶ 2,831:
say /*display blank line for the separator.*/
say 'The sum of' right(N,w) "terms is:" /*display the sum's preamble line. */
say $ /*stick a fork in it, we're all done. */</
'''output''' when using the input of (one billion [limit], and one hundred decimal digits): <tt> 1000000000 100 </tt>
<pre>
Line 2,510 ⟶ 2,859:
=={{header|Ring}}==
<syntaxhighlight lang="ring">
sum = 0
for i =1 to 1000
Line 2,517 ⟶ 2,866:
decimals(8)
see sum
</syntaxhighlight>
=={{header|RLaB}}==
<syntaxhighlight lang="rlab">
>> sum( (1 ./ [1:1000]) .^ 2 ) - const.pi^2/6
-0.000999500167
</syntaxhighlight>
=={{header|RPL}}==
≪ 0 1 ROT '''FOR''' k SQ INV + '''NEXT''' ≫ '<span style="color:blue">∑INV2</span>'''' STO
1000 <span style="color:blue">∑INV2</span>
The emulator immediately returns
1: 1.64393456668
A basic HP-28S calculator returns after 27.5 seconds
1: 1.64393456674
{{works with|HP|49}}
'k' 1 1000 '1/SQ(k)' ∑
returns in 2 minutes 27 seconds, with exact mode set:
1: 83545938483149689478187854264854884386044454314086472930763839512603803291207881839588904977469387999844962675327115010933903589145654299730231109091124308462732153297321867661093162618281746011828755017021645889046777854795025297006943669294330752479399654716368801794529682603741344724733173765262964463970763934463926259796895140901128384286333311745462863716753134735154188954742414035836608258393970996630553795415075904205673610359458498106833291961256452756993199997231825920203667952667546787052535763624910912251107083702817265087341966845358732584971361645348091123849687614886682117125784781422103460192439394780707024963279033532646857677925648889105430050030795563141941157379481719403833258405980463950499887302926152552848089894630843538497552630691676216896740675701385847032173192623833881016332493844186817408141003602396236858699094240207812766449 / 50820720104325812617835292273000760481839790754374852703215456050992581046448162621598030244504097240825920773913981926305208272518886258627010933716354037062979680120674828102224650586465553482032614190502746121717248161892239954030493982549422690846180552358769564169076876408783086920322038142618269982747137757706040198826719424371333781947889528085329853597116893889786983109597085041878513917342099206896166585859839289193299599163669641323895022932959750057616390808553697984192067774252834860398458100840611325353202165675189472559524948330224159123505567527375848194800452556940453530457590024173749704941834382709198515664897344438584947842793131829050180589581507273988682409028088248800576590497216884808783192565859896957125449502802395453976401743504938336291933628859306247684023233969172475385327442707968328512729836445886537101453118476390400000000
=={{header|Ruby}}==
<
{{out}}
<pre>
Line 2,533 ⟶ 2,895:
=={{header|Run BASIC}}==
<
for i =1 to 1000
sum = sum + 1 /( i^2)
next i
print sum</
=={{header|Rust}}==
<
const UPPER: i32 = 1000;
Line 2,552 ⟶ 2,914:
println!("{}", (LOWER..UPPER + 1).fold(0, |sum, x| sum + x));
}
</syntaxhighlight>
=={{header|SAS}}==
<
s=0;
do n=1 to 1000;
Line 2,562 ⟶ 2,924:
e=s-constant('pi')**2/6;
put s e;
run;</
=={{header|Scala}}==
<
res30: Double = 1.6439345666815615</
=={{header|Scheme}}==
<
(do ((i a (+ i 1))
(result 0 (+ result (fn i))))
Line 2,575 ⟶ 2,937:
(sum 1 1000 (lambda (x) (/ 1 (* x x)))) ; fraction
(exact->inexact (sum 1 1000 (lambda (x) (/ 1 (* x x))))) ; decimal</
More idiomatic way (or so they say) by tail recursion:
<
(let loop ((f f) (s 0))
(if (> f to)
Line 2,586 ⟶ 2,948:
;; whether you get a rational or a float depends on implementation
(invsq 1 1000) ; 835459384831...766449/50820...90400000000
(exact->inexact (invsq 1 1000)) ; 1.64393456668156</
=={{header|Seed7}}==
<
include "float.s7i";
Line 2,604 ⟶ 2,966:
end for;
writeln(sum digits 6 lpad 8);
end func;</
=={{header|SETL}}==
<syntaxhighlight lang="setl">print( +/[1/k**2 : k in [1..1000]] );</syntaxhighlight>
{{out}}
<pre>1.64393456668156</pre>
=={{header|Sidef}}==
<
Alternatively, using the ''reduce{}'' method:
<
{{out}}
Line 2,621 ⟶ 2,988:
Manually coerce it to a float, otherwise you will get an exact (and slow) answer:
<
=={{header|Smalltalk}}==
<
sum + (aNumber squared reciprocal) ] ) asFloat displayNl.</
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "sumseries" )
@( description, "Compute the nth term of a series, i.e. the " )
@( description, "sum of the n first terms of the " )
@( description, "corresponding sequence. For this task " )
@( description, "repeat 1000 times. " )
@( see_also, "http://rosettacode.org/wiki/Sum_of_a_series" )
@( author, "Ken O. Burtch" );
pragma license( unrestricted );
pragma restriction( no_external_commands );
procedure sumseries is
function inverse_square( x : long_float ) return long_float is
begin
return 1/x**2;
end inverse_square;
total : long_float := 0.0;
max_param : constant natural := 1000;
begin
for i in 1..max_param loop
total := @ + inverse_square( i );
end loop;
put( "Sum of F(x) from 1 to" )
@( max_param )
@( " is" )
@( total );
new_line;
end sumseries;</syntaxhighlight>
=={{header|SQL}}==
<
-- this is postgresql specific, fill the table
insert into t1 (select generate_series(1,1000)::real);
Line 2,634 ⟶ 3,037:
select 1/(n*n) as recip from t1
) select sum(recip) from tt;
</syntaxhighlight>
Result of select (with locale DE):
<pre>
Line 2,644 ⟶ 3,047:
=={{header|Stata}}==
<
return(sum((n..1):^-2))
}
series(1000)-pi()^2/6
-.0009995002</
=={{header|Swift}}==
<syntaxhighlight lang="swift">
func sumSeries(var n: Int) -> Double {
var ret: Double = 0
Line 2,664 ⟶ 3,067:
output: 1.64393456668156
</syntaxhighlight>
<syntaxhighlight lang="text">
Swift also allows extension to datatypes. Here's similar code using an extension to Int.
Line 2,689 ⟶ 3,092:
y = 1000.sumSeries()
</syntaxhighlight>
=={{header|Tcl}}==
Line 2,695 ⟶ 3,098:
=== 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
lsum_series [range 1 1001] ;# ==> 1.6439345666815615</
=== Using Loop ===
{{works with|Tcl|8.5}}
<
proc partial_sum {func - start - stop} {
Line 2,715 ⟶ 3,118:
set S {x {expr {1.0 / $x**2}}}
partial_sum $S from 1 to 1000 ;# => 1.6439345666815615</
=== Using tcllib ===
{{tcllib|struct::list}}
<
package require struct::list
Line 2,728 ⟶ 3,131:
set S {x {expr {1.0 / $x**2}}}
sum_of $S [range 1 1001] ;# ==> 1.6439345666815615</
The helper <code>range</code> procedure is:
<
proc range args {
foreach {start stop step} [switch -exact -- [llength $args] {
Line 2,746 ⟶ 3,149:
}
return $range
}</
=={{header|TI-83 BASIC}}==
Line 2,752 ⟶ 3,155:
{{trans|TI-89 BASIC}}
{{works with|TI-83 BASIC|TI-84Plus 2.55MP}}
<
∑(1/X²,X,1,1000)
</syntaxhighlight>
{{out}}
<pre>
Line 2,763 ⟶ 3,166:
The TI-83 does not have the new summation notation, and caps lists at 999 entries.
<
{{out}}
<pre>
Line 2,771 ⟶ 3,174:
=={{header|TI-89 BASIC}}==
<
=={{header|TXR}}==
Line 2,779 ⟶ 3,182:
Variant A1: limit the list generation inside the <code>gen</code> operator.
<
1.64393456668156</
Variant A2: generate infinite list, but take only the first 1000 items using <code>[list-expr 0..999]</code>.
<
1.64393456668156</
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.
<
1.64393456668156</
Variant C: unravel the chain in Variant B using straightforward nesting.
<
1.64393456668156</
Variant D: bring Variant B's inverse square calculation into the fold, eliminating mapcar. Final answer.
<
1.64393456668156</
=={{header|Unicon}}==
Line 2,806 ⟶ 3,209:
=={{header|UnixPipes}}==
<
b=$1;res=$2
echo "scale=5;1/($res*$res)+$b" | bc
Line 2,823 ⟶ 3,226:
}
(echo 3; echo 1; echo 4) | fold sum</
=={{header|Ursala}}==
Line 2,831 ⟶ 3,234:
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
total = plus:-0 div/*1. sqr* float*t iota 1001</
output:
<pre>1.643935e+00</pre>
=={{header|Vala}}==
<
public static void main(){
int i, start = 1, end = 1000;
Line 2,851 ⟶ 3,254:
stdout.printf("%s\n", sum.to_string());
}
</syntaxhighlight>
Output:
Line 2,859 ⟶ 3,262:
=={{header|VBA}}==
<
Dim res As Double
For i = 1 To n
Line 2,868 ⟶ 3,271:
Public Sub main()
Debug.Print sumto(1000)
End Sub</
<pre> 1,64393456668156 </pre>
=={{header|VBScript}}==
<
for i=1 to 1000
s=s+1/i^2
next
wscript.echo s </
{{out}}
<pre>
Line 2,885 ⟶ 3,288:
{{trans|VBScript}}
{{works with|Visual Basic .NET|2013}}
<
Sub SumOfaSeries()
Dim s As Double
Line 2,893 ⟶ 3,296:
Next 'i
Console.WriteLine(s)
End Sub </
{{out}}
<pre>
1.64393456668156
</pre>
=={{header|Verilog}}==
<syntaxhighlight lang="Verilog">module main;
integer i;
real sum;
initial begin
sum = 0.0;
for(i = 1; i <= 1000; i=i+1) sum = sum + 1.0 / (i * i);
$display(sum);
end
endmodule</syntaxhighlight>
<pre>1.64393</pre>
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">import math
fn main(){
println('known: ${math.pi*math.pi/6}')
mut sum := f64(0)
for i :=1e3; i >0; i-- {
sum += 1/(i*i)
}
println('computed: $sum')
}</syntaxhighlight>
Output:
<pre>known: 1.6449340668482264
computed: 1.6439345666815597</pre>
=={{header|WDTE}}==
<
s.range 1 1001
Line 2,906 ⟶ 3,338:
-> s.reduce 0 +
-- io.writeln io.stdout
;</
{{out}}
Line 2,912 ⟶ 3,344:
=={{header|Wortel}}==
<
<
#~V1Sn ; number expression which stands for: square push(1) swap divide
!* ; maps the number expression over the list
@sum ; sums the list</
=={{header|Wren}}==
<
System.print("s(1000) = %(sumSeries.call(1000))")
System.print("zeta(2) = %(Num.pi*Num.pi/6)")</
{{out}}
Line 2,931 ⟶ 3,363:
=={{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:
Line 2,944 ⟶ 3,376:
=={{header|Yorick}}==
<
=={{header|Zig}}==
{{Works with|Zig|0.11.0}}
<syntaxhighlight lang="zig">const std = @import("std");
fn f(x: u64) f64 {
return 1 / @as(f64, @floatFromInt(x * x));
}
fn sum(comptime func: fn (u64) f64, n: u64) f64 {
var s: f64 = 0.0;
var i: u64 = n;
while (i != 0) : (i -= 1)
s += func(i);
return s;
}
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("S_1000 = {d:.15}\n", .{sum(f, 1000)});
}</syntaxhighlight>{{out}}
<pre>S_1000 = 1.643934566681560</pre>
=={{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
60 PRINT s</
{{out}}
<pre>
|