Continued fraction: Difference between revisions
m
→{{header|Fōrmulæ}}
Drkameleon (talk | contribs) (Added Arturo implementation) |
|||
(27 intermediate revisions by 15 users not shown) | |||
Line 23:
=={{header|11l}}==
<
V r = 0.0
L n > 0
Line 32:
print(calc(n -> I n > 0 {2} E 1, n -> 1))
print(calc(n -> I n > 0 {n} E 2, n -> I n > 1 {n - 1} E 1))
print(calc(n -> I n > 0 {6} E 3, n -> (2 * n - 1) ^ 2))</
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<
DEFINE PTR="CARD"
Line 142:
Calc(piA,piB,500,res)
Print(" Pi=") PrintRE(res)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Continued_fraction.png Screenshot from Atari 8-bit computer]
Line 155:
Generic function for estimating continued fractions:
<
type Scalar is digits <>;
with function A (N : in Natural) return Natural;
with function B (N : in Positive) return Natural;
function Continued_Fraction (Steps : in Natural) return Scalar;</
<
function A (N : in Natural) return Scalar is (Scalar (Natural'(A (N))));
function B (N : in Positive) return Scalar is (Scalar (Natural'(B (N))));
Line 172:
end loop;
return A (0) + Fraction;
end Continued_Fraction;</
Test program using the function above to estimate the square root of 2, Napiers constant and pi:
<
with Continued_Fraction;
Line 208:
Put (Napiers_Constant.Estimate (200), Exp => 0); New_Line;
Put (Pi.Estimate (10000), Exp => 0); New_Line;
end Test_Continued_Fractions;</
===Using only Ada 95 features===
This example is exactly the same as the preceding one, but implemented using only Ada 95 features.
<
type Scalar is digits <>;
with function A (N : in Natural) return Natural;
with function B (N : in Positive) return Natural;
function Continued_Fraction_Ada95 (Steps : in Natural) return Scalar;</
<
function A (N : in Natural) return Scalar is
begin
Line 235:
end loop;
return A (0) + Fraction;
end Continued_Fraction_Ada95;</
<
with Continued_Fraction_Ada95;
Line 322:
Put (Napiers_Constant.Estimate (200), Exp => 0); New_Line;
Put (Pi.Estimate (10000), Exp => 0); New_Line;
end Test_Continued_Fractions_Ada95;</
{{out}}
<pre> 1.41421356237310
Line 330:
=={{header|ALGOL 68}}==
{{works with|Algol 68 Genie|2.8}}
<syntaxhighlight lang="algol68">
PROC cf = (INT steps, PROC (INT) INT a, PROC (INT) INT b) REAL:
BEGIN
Line 356:
print (("Napier: ", cf(precision, anap, bnap), newline));
print (("Pi: ", cf(precision, api, bpi)))
</syntaxhighlight>
{{out}}
<pre>
Line 366:
=={{header|Arturo}}==
{{trans|Nim}}
<
[a, b, temp]: 0.0
Line 396:
print calc 'sqrt2 20
print calc 'napier 15
print calc 'Pi 10000</
{{out}}
Line 406:
=={{header|ATS}}==
A fairly direct translation of the [[#C|C version]] without using advanced features of the type system:
<
"share/atspre_staload.hats"
//
Line 475:
println! ("napier = ", calc(napier, 100));
println! (" pi = ", calc( pi , 100));
) (* end of [main0] *)</
=={{header|AutoHotkey}}==
<
{
return n?2.0:1.0
Line 524:
}
Msgbox, % "sqrt 2 = " . calc("sqrt2", 1000) . "`ne = " . calc("napier", 1000) . "`npi = " . calc("pi", 1000)</
Output with Autohotkey v1 (currently 1.1.16.05):
<
e = 2.718282
pi = 3.141593</
Output with Autohotkey v2 (currently alpha 56):
<
e = 2.7182818284590455
pi = 3.1415926533405418</
Note the far superiour accuracy of v2.
=={{header|Axiom}}==
Axiom provides a ContinuedFraction domain:
<
get continuedFraction(1, repeating [1], repeating [2]) :: Float
get continuedFraction(2, cons(1,[i for i in 1..]), [i for i in 1..]) :: Float
get continuedFraction(3, [i^2 for i in 1.. by 2], repeating [6]) :: Float</
Output:<
Type: Float
Line 548:
(3) 3.1415926538 39792926
Type: Float</
The value for <math>\pi</math> has an accuracy to only 9 decimal places after 1000 iterations, with an accuracy to 12 decimal places after 10000 iterations.
We could re-implement this, with the same output:
<
n=1 => initial
temp := 0
Line 560:
cf(1, repeating [1], repeating [2], 1000) :: Float
cf(2, cons(1,[i for i in 1..]), [i for i in 1..], 1000) :: Float
cf(3, [i^2 for i in 1.. by 2], repeating [6], 1000) :: Float</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
@% = &1001010
Line 579:
expr$ += STR$(EVAL(a$)) + "+" + STR$(EVAL(b$)) + "/("
UNTIL LEN(expr$) > (65500 - N)
= a0 + b1 / EVAL (expr$ + "1" + STRING$(N, ")"))</
{{out}}
<pre>
Line 589:
=={{header|C}}==
{{works with|ANSI C}}
<
#include <stdio.h>
Line 659:
return 0;
}</
{{out}}
<pre> 1.414213562
Line 667:
=={{header|C sharp|C#}}==
{{trans|Java}}
<
using System.Collections.Generic;
Line 692:
}
}
}</
{{out}}
<pre>1.4142135623731
Line 699:
=={{header|C++}}==
<
#include <iostream>
#include <tuple>
Line 740:
<< calc(pi, 10000) << '\n'
<< std::setprecision(old_prec); // reset precision
}</
{{out}}
<pre>
Line 751:
Functions don't take other functions as arguments, so I wrapped them in a dummy record each.
<
var r = 0.0;
Line 785:
writeln(calc(new Sqrt2(), n));
writeln(calc(new Napier(), n));
writeln(calc(new Pi(), n));</
=={{header|Clojure}}==
<
(defn cfrac
[a b n]
Line 797:
(def e (cfrac #(if (zero? %) 2.0 %) #(if (= 1 %) 1.0 (double (dec %))) 100))
(def pi (cfrac #(if (zero? %) 3.0 6.0) #(let [x (- (* 2.0 %) 1.0)] (* x x)) 900000))
</syntaxhighlight>
{{out}}
<pre>
Line 809:
{{works with|GnuCOBOL}}
<
program-id. show-continued-fractions.
Line 994:
goback.
end program pi-beta.
</syntaxhighlight>
{{out}}
Line 1,003:
=={{header|CoffeeScript}}==
<
# a0 + b1 / (a1 + b2 / (a2 + b3 / ...
continuous_fraction = (f) ->
Line 1,037:
x = 2*n - 1
x * x
p Math.PI, continuous_fraction(fpi)</
{{out}}
<pre>
Line 1,054:
=={{header|Common Lisp}}==
{{trans|C++}}
<
(let ((temp 0))
(loop for n1 from n downto 1
Line 1,077:
(* (1- (* 2 n))
(1- (* 2 n))))) 10000)
'double-float))</
{{out}}
<pre>sqrt(2) = 1.4142135623730947d0
Line 1,084:
=={{header|D}}==
<
FP calc(FP, F)(in F fun, in int n) pure nothrow if (isCallable!F) {
Line 1,114:
calc!real(&fNapier, 200).print;
calc!real(&fPi, 200).print;
}</
{{out}}
<pre>1.4142135623730950487
2.7182818284590452354
3.1415926228048469486</pre>
=={{header|dc}}==
<syntaxhighlight lang="dc">[20k 0 200 si [li lbx r li lax + / li 1 - dsi 0<:]ds:x 0 lax +]sf
[[2q]s2[0<2 1]sa[R1]sb]sr # sqrt(2)
[[R2q]s2[d 0=2]sa[R1q]s1[d 1=1 1-]sb]se # e
[[3q]s3[0=3 6]sa[2*1-d*]sb]sp # pi
c lex lfx p
lrx lfx p
lpx lfx p</syntaxhighlight>
{{out}}
<pre>3.14159262280484694855
1.41421356237309504880
2.71828182845904523536</pre>
20 decimal places and 200 iterations.
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
numfmt 8 0
func calc_sqrt .
n = 100
sum = n
while n >= 1
a = 1
if n > 1
a = 2
.
b = 1
sum = a + b / sum
n -= 1
.
return sum
.
func calc_e .
n = 100
sum = n
while n >= 1
a = 2
if n > 1
a = n - 1
.
b = 1
if n > 1
b = n - 1
.
sum = a + b / sum
n -= 1
.
return sum
.
func calc_pi .
n = 100
sum = n
while n >= 1
a = 3
if n > 1
a = 6
.
b = 2 * n - 1
b *= b
sum = a + b / sum
n -= 1
.
return sum
.
print calc_sqrt
print calc_e
print calc_pi
</syntaxhighlight>
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">
defmodule CFrac do
def compute([a | _], []), do: a
def compute([a | as], [b | bs]), do: a + b/compute(as, bs)
def sqrt2 do
a = [1 | Stream.cycle([2]) |> Enum.take(1000)]
b = Stream.cycle([1]) |> Enum.take(1000)
IO.puts compute(a, b)
end
def exp1 do
a = [2 | Stream.iterate(1, &(&1 + 1)) |> Enum.take(1000)]
b = [1 | Stream.iterate(1, &(&1 + 1)) |> Enum.take(999)]
IO.puts compute(a, b)
end
def pi do
a = [3 | Stream.cycle([6]) |> Enum.take(1000)]
b = 1..1000 |> Enum.map(fn k -> (2*k - 1)**2 end)
IO.puts compute(a, b)
end
end
</syntaxhighlight>
{{out}}
<pre>
>elixir -e CFrac.sqrt2()
1.4142135623730951
>elixir -e CFrac.exp1()
2.7182818284590455
>elixir -e CFrac.pi()
3.141592653340542
</pre>
=={{header|Erlang}}==
<
-module(continued).
-compile([export_all]).
Line 1,165 ⟶ 1,275:
test_nappier (N) ->
continued_fraction(fun nappier_a/1,fun nappier_b/1,N).
</syntaxhighlight>
{{out}}
<
29> continued:test_pi(1000).
3.141592653340542
Line 1,175 ⟶ 1,285:
31> continued:test_nappier(1000).
2.7182818284590455
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
===The Functions===
<
// I provide four functions:-
// cf2S general purpose continued fraction to sequence of float approximations
Line 1,191 ⟶ 1,301:
let cfSqRt n=(cf2S (fun()->n-1M) (let mutable n=false in fun()->if n then 2M else (n<-true; 1M)))
let π n=let mutable π=n in (fun ()->match π with h::t->π<-t; h |_->9999999999999999999999999999M)
</syntaxhighlight>
===The Tasks===
<
cfSqRt 2M |> Seq.take 10 |> Seq.pairwise |> Seq.iter(fun(n,g)->printfn "%1.14f < √2 < %1.14f" (min n g) (max n g))
</syntaxhighlight>
{{out}}
<pre>
Line 1,208 ⟶ 1,318:
1.41421355164605 < √2 < 1.41421362489487
</pre>
<
cfSqRt 0.25M |> Seq.take 30 |> Seq.iter (printfn "%1.14f")
</syntaxhighlight>
{{out}}
<pre>
Line 1,244 ⟶ 1,354:
0.50000000000000
</pre>
<
let aπ()=let mutable n=0M in (fun ()->n<-n+1M;let b=n+n-1M in b*b)
let bπ()=let mutable n=true in (fun ()->match n with true->n<-false;3M |_->6M)
cf2S (aπ()) (bπ()) |> Seq.take 10 |> Seq.pairwise |> Seq.iter(fun(n,g)->printfn "%1.14f < π < %1.14f" (min n g) (max n g))
</syntaxhighlight>
{{out}}
<pre>
Line 1,261 ⟶ 1,371:
3.14140671849650 < π < 3.14183961892940
</pre>
<
let pi = π [3M;7M;15M;1M;292M;1M;1M;1M;2M;1M;3M;1M;14M;2M;1M;1M;2M;2M;2M;2M]
cN2S pi |> Seq.take 10 |> Seq.pairwise |> Seq.iter(fun(n,g)->printfn "%1.14f < π < %1.14f" (min n g) (max n g))
</syntaxhighlight>
{{out}}
<pre>
Line 1,277 ⟶ 1,387:
3.14159265358939 < π < 3.14159265359140
</pre>
<
let ae()=let mutable n=0.5M in (fun ()->match n with 0.5M->n<-0M; 1M |_->n<-n+1M; n)
let be()=let mutable n=0.5M in (fun ()->match n with 0.5M->n<-0M; 2M |_->n<-n+1M; n)
cf2S (ae()) (be()) |> Seq.take 10 |> Seq.pairwise |> Seq.iter(fun(n,g)->printfn "%1.14f < e < %1.14f" (min n g) (max n g))
</syntaxhighlight>
{{out}}
<pre>
Line 1,293 ⟶ 1,403:
2.71828165766640 < e < 2.71828184277783
2.71828182735187 < e < 2.71828184277783
</pre>
===Apéry's constant===
See [https://tpiezas.wordpress.com/2012/05/04/continued-fractions-for-zeta2-and-zeta3/ Continued fractions for Zeta(2) and Zeta(3)] section II. Zeta(3)
<syntaxhighlight lang="fsharp">
let aπ()=let mutable n=0 in (fun ()->n<-n+1;-decimal(pown n 6))
let bπ()=let mutable n=0M in (fun ()->n<-n+1M; (2M*n-1M)*(17M*n*n-17M*n+5M))
cf2S (aπ()) (bπ()) |>Seq.map(fun n->6M/n) |> Seq.take 10 |> Seq.pairwise |> Seq.iter(fun(n,g)->printfn "%1.20f < p < %- 1.20f" (min n g) (max n g));;
</syntaxhighlight>
{{out}}
<pre>
1.20205479452054794521 < p < 1.20205690119184928874
1.20205690119184928874 < p < 1.20205690315781676650
1.20205690315781676650 < p < 1.20205690315959270361
1.20205690315959270361 < p < 1.20205690315959428400
1.20205690315959428400 < p < 1.20205690315959428540
1.20205690315959428540 < p < 1.20205690315959428540
1.20205690315959428540 < p < 1.20205690315959428540
1.20205690315959428540 < p < 1.20205690315959428540
1.20205690315959428540 < p < 1.20205690315959428540
</pre>
=={{header|Factor}}==
''cfrac-estimate'' uses [[Arithmetic/Rational|rational arithmetic]] and never truncates the intermediate result. When ''terms'' is large, ''cfrac-estimate'' runs slow because numerator and denominator grow big.
<
math.ranges prettyprint sequences ;
IN: rosetta.cfrac
Line 1,359 ⟶ 1,488:
PRIVATE>
MAIN: main</
{{out}}
<pre> Square root of 2: 1.414213562373095048801688724209
Line 1,366 ⟶ 1,495:
=={{header|Felix}}==
<
let a = match n with | 0 => 3.0 | _ => 6.0 endmatch in
let b = pow(2.0 * n.double - 1.0, 2.0) in
Line 1,392 ⟶ 1,521:
println$ cf_iter 200 sqrt_2; // => 1.41421
println$ cf_iter 200 napier; // => 2.71818
println$ cf_iter 1000 pi; // => 3.14159</
=={{header|Forth}}==
{{trans|D}}
<
: fnapier dup dup 1 > if 1- else drop 1 then s>f dup 1 < if drop 2 then s>f ;
: fpi dup 2* 1- dup * s>f 0> if 6 else 3 then s>f ;
Line 1,404 ⟶ 1,533:
do i over execute frot f+ f/ -1 +loop
0 swap execute fnip f+ \ calcucate for 0
;</
{{out}}
<pre>
Line 1,416 ⟶ 1,545:
=={{header|Fortran}}==
<
implicit none
Line 1,514 ⟶ 1,643:
end function
end program examples</
{{out}}
<pre>
Line 1,523 ⟶ 1,652:
=={{header|FreeBASIC}}==
<
function sqrt2_a( n as uinteger ) as uinteger
Line 1,560 ⟶ 1,689:
print calc_contfrac( @sqrt2_a, @sqrt2_b, MAX )
print calc_contfrac( @napi_a, @napi_b, MAX )
print calc_contfrac( @pi_a, @pi_b, MAX )</
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Continued_fraction}}
'''Solution'''
The following function definition creates a continued fraction:
[[File:Fōrmulæ - Continued fraction 01.png]]
The function accepts the following parameters:
{| class="wikitable" style="margin:auto"
|-
! Parameter !! Description
|-
| a₀ || Value for a₀
|-
| λa || Lambda expression to define aᵢ
|-
| λb || Lambda expression to define bᵢ
|-
| depth || Depth to calculate the continued fraction
|}
Since Fōrmulæ arithmetic simplifies numeric results as they are generated, the result is not a continued fraction by default.
If we want to create the structure, we can introduce the parameters as string or text expressions (or lambda expressions that produce them). Because string or text expressions are not reduced when they are operands of additions and divisions, the structure is preserved, such as follows:
[[File:Fōrmulæ - Continued fraction 02.png]]
[[File:Fōrmulæ - Continued fraction 03.png]]
'''Case 1.''' <math>\sqrt 2</math>
In this case
* a₀ is 1
* λa is n ↦ 2
* λb is n ↦ 1
Let us show the results as a table, for several levels of depth (1 to 10).
The columns are:
* The depth
* The "textual" call, in order to generate the structure
* The normal (numeric) call. Since arithmetic operations are exact by default, it is usually a rational number.
* The value of the normal (numeric) call, forced to be shown as a decimal number, by using the Math.Numeric expression (the N(x) expression)
[[File:Fōrmulæ - Continued fraction 04.png]]
[[File:Fōrmulæ - Continued fraction 05.png]]
'''Case 2.''' <math>e</math>
In this case
* a₀ is 2
* λa is n ↦ n
* λb is n ↦ 1 if n = 1, n - 1 elsewhere
[[File:Fōrmulæ - Continued fraction 06.png]]
[[File:Fōrmulæ - Continued fraction 07.png]]
'''Case 3.''' <math>\pi</math>
In this case
* a₀ is 3
* λa is n ↦ 6
* λb is n ↦ 2(n - 1)²
[[File:Fōrmulæ - Continued fraction 08.png]]
[[File:Fōrmulæ - Continued fraction 09.png]]
=={{header|Go}}==
<
import "fmt"
Line 1,623 ⟶ 1,822:
fmt.Println("nap: ", cfNap(20).real())
fmt.Println("pi: ", cfPi(20).real())
}</
{{out}}
<pre>
Line 1,633 ⟶ 1,832:
=={{header|Groovy}}==
{{trans|Java}}
<
import static java.lang.Math.pow
Line 1,657 ⟶ 1,856:
System.out.println(calc(f, 200))
}
}</
{{out}}
<pre>1.4142135623730951
Line 1,664 ⟶ 1,863:
=={{header|Haskell}}==
<
import Data.Char (intToDigit)
Line 1,695 ⟶ 1,894:
(putStrLn .
take 200 . decString . (approxCF 950 :: [(Integer, Integer)] -> Rational))
[sqrt2, napier, myPi]</
{{out}}
<pre>
Line 1,702 ⟶ 1,901:
3.141592653297590947683406834261190738869139611505752231394089152890909495973464508817163306557131591579057202097715021166512662872910519439747609829479577279606075707015622200744006783543589980682386
</pre>
<
import Data.Bool (bool)
Line 1,738 ⟶ 1,937:
main :: IO ()
main = mapM_ putStrLn [cf2dec 200 sqrt2, cf2dec 200 napier, cf2dec 200 pie]</
=={{header|Icon}}==
<syntaxhighlight lang="icon">
$define EVAL_DEPTH 100
# A generalized continued fraction, represented by two functions. Each
# function maps from an index to a floating-point value.
record continued_fraction (a, b)
procedure main ()
writes (" sqrt 2.0 = ")
write (evaluate_continued_fraction (continued_fraction (sqrt2_a, sqrt2_b),
EVAL_DEPTH))
writes (" e = ")
write (evaluate_continued_fraction (continued_fraction (e_a, e_b),
EVAL_DEPTH))
writes (" pi = ")
write (evaluate_continued_fraction (continued_fraction (pi_a, pi_b),
EVAL_DEPTH))
end
procedure evaluate_continued_fraction (frac, depth)
local i, retval
retval := frac.a (depth)
every i := depth to 1 by -1 do {
retval := frac.a (i - 1) + (frac.b (i) / retval)
}
return retval
end
procedure sqrt2_a (i)
return (if i = 0 then 1.0 else 2.0)
end
procedure sqrt2_b (i)
return 1.0
end
procedure e_a (i)
return (if i = 0 then 2.0 else real (i))
end
procedure e_b (i)
return (if i = 1 then 1.0 else real (i - 1))
end
procedure pi_a (i)
return (if i = 0 then 3.0 else 6.0)
end
procedure pi_b (i)
return real (((2 * i) - 1)^2)
end
</syntaxhighlight>
{{out}}
<pre>$ icon continued-fraction-task.icn
sqrt 2.0 = 1.414213562
e = 2.718281828
pi = 3.141592411
</pre>
=={{header|J}}==
<
sqrt2=: cfrac 1 1,200$2 1x
Line 1,754 ⟶ 2,014:
1.4142135623730950488016887242096980785696718753769480731766797379907324784621205551109457595775322165
3.1415924109
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274</
Note that there are two kinds of continued fractions. The kind here where we alternate between '''a''' and '''b''' values, but in some other tasks '''b''' is always 1 (and not included in the list we use to represent the continued fraction). The other kind is evaluated in J using <code>(+%)/</code> instead of <code>+`%/</code>.
Line 1,761 ⟶ 2,021:
{{trans|D}}
{{works with|Java|8}}
<
import java.util.*;
import java.util.function.Function;
Line 1,785 ⟶ 2,045:
System.out.println(calc(f, 200));
}
}</
<pre>1.4142135623730951
2.7182818284590455
Line 1,808 ⟶ 2,068:
computes the continued fraction until the difference in approximations is less than or equal to delta,
which may be 0, as previously noted.
<syntaxhighlight lang="jq">
# "first" is the first triple, e.g. [1,a,b];
#
def continued_fraction( first; next; count ):
# input: [i, a, b
def cf:
if .[0] == count then 0
Line 1,834 ⟶ 2,094:
end;
[2,null] | cf;
</syntaxhighlight>
'''Examples''':
The convergence for pi is slow so we select delta = 1e-12 in that case.
<
"2|sqrt : \(2|sqrt) : \(continued_fraction_delta( [1,1,1]; [.[0]+1, 2, 1]; 0))",
"1|exp : \(1|exp) : \(2 + (1 / (continued_fraction_delta( [1,1,1]; [.[0]+1, .[1]+1, .[2]+1]; 0))))",
"pi : \(1|atan * 4) : \(continued_fraction_delta( [1,3,1]; .[0]+1 | [., 6, ((2*. - 1) | (.*.))]; 1e-12)) (1e-12)"
</syntaxhighlight>
{{Out}}
<
Value : Direct : Continued Fraction
2|sqrt : 1.4142135623730951 : 1.4142135623730951
1|exp : 2.718281828459045 : 2.7182818284590455
pi : 3.141592653589793 : 3.1415926535892935 (1e-12)</
=={{header|Julia}}==
{{works with|Julia|
High performant lazy evaluation on demand with Julias iterators.
<syntaxhighlight lang="julia">
using .Iterators: countfrom, flatten, repeated, zip
using .MathConstants: ℯ
using Printf
function
m = BigInt[a₀ 1; 1 0]
for (aᵢ, bᵢ) ∈ zip(a, b)
end
m[1]/m[2]
end
out((k, v)) = @printf "%2s: %.12f ≈ %.12f\n" k v eval(k)
foreach(out, (
:(√2) => cf(1, repeated(2)),
:ℯ => cf(2, countfrom(), flatten((1, countfrom()))),
:π => cf(3, repeated(6), (k^2 for k ∈ countfrom(1, 2)))))
</syntaxhighlight>
{{out}}
<pre>
ℯ: 2.718281828459 ≈ 2.718281828459
=={{header|Klong}}==
<syntaxhighlight lang="k">
cf::{[f g i];f::x;g::y;i::z;
f(0)+z{i::i-1;g(i+1)%f(i+1)+x}:*0}
Line 1,901 ⟶ 2,146:
cf({:[0=x;2;x]};{:[x>1;x-1;x]};1000)
cf({:[0=x;3;6]};{((2*x)-1)^2};1000)
</syntaxhighlight>
{{out}}
<pre>
Line 1,912 ⟶ 2,157:
=={{header|Kotlin}}==
{{trans|D}}
<
typealias Func = (Int) -> IntArray
Line 1,932 ⟶ 2,177:
)
for (pair in pList) println("${pair.first} = ${calc(pair.second, 200)}")
}</
{{out}}
Line 1,943 ⟶ 2,188:
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def gcf
Line 1,998 ⟶ 2,243:
// Much quicker, 15 exact decimals after 15 iterations
</syntaxhighlight>
=={{header|Lua}}==
{{trans|C}}
<
local a = 0.0
local b = 0.0
Line 2,068 ⟶ 2,313:
end
main()</
{{out}}
<pre>1.4142135623731
Line 2,075 ⟶ 2,320:
=={{header|Maple}}==
<syntaxhighlight lang="maple">
contfrac:=n->evalf(Value(NumberTheory:-ContinuedFraction(n)));
contfrac(2^(0.5));
contfrac(Pi);
contfrac(exp(1));
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
napier=Function[n,{2,Transpose@{Range[n],Prepend[Range[n-1],1]}}];
pi=Function[n,{3,Transpose@{Array[6&,n],Array[(2#-1)^2&,n]}}];
approx=Function[l,
N[Divide@@First@Fold[{{#2.#[[;;,1]],#2.#[[;;,2]]},#[[1]]}&,{{l[[2,1,1]]l[[1]]+l[[2,1,2]],l[[2,1,1]]},{l[[1]],1}},l[[2,2;;]]],10]];
r2=approx/@{sqrt2@#,napier@#,pi@#}&@10000;r2//TableForm</
{{out}}
<pre>
Line 2,097 ⟶ 2,342:
=={{header|Maxima}}==
<
for i from n step -1 thru 2 do z: b[i]/(a[i] + z), a[1] + z)$
Line 2,119 ⟶ 2,364:
fpprec: 20$
x: cfeval(cf_pi(10000))$
bfloat(x - %pi); /* 2.4999999900104930006b-13 */</
=={{header|NetRexx}}==
<
* Derived from REXX ... Derived from PL/I with a little "massage"
* SQRT2= 1.41421356237309505 <- PL/I Result
Line 2,174 ⟶ 2,419:
end
Get_Coeffs(form,0)
return (a + temp)</
Who could help me make a,b,sqrt2,napier,pi global (public) variables?
This would simplify the solution:-)
Line 2,187 ⟶ 2,432:
=={{header|Nim}}==
<
var a, b, temp = 0.0
for i in countdown(n, 1):
Line 2,213 ⟶ 2,458:
echo calc(sqrt2, 20)
echo calc(napier, 15)
echo calc(pi, 10000)</
{{out}}
<pre>1.414213562373095
Line 2,220 ⟶ 2,465:
=={{header|OCaml}}==
<
and nap = 2, fun n -> (max 1 (n-1), n)
and root2 = 1, fun n -> (1, 2) in
Line 2,233 ⟶ 2,478:
Printf.printf "sqrt(2)\t= %.15f\n" (eval root2 1000);
Printf.printf "e\t= %.15f\n" (eval nap 1000);
Printf.printf "pi\t= %.15f\n" (eval pi 1000);</
Output (inaccurate due to too few terms):
<pre>sqrt(2) = 1.414213562373095
Line 2,241 ⟶ 2,486:
=={{header|PARI/GP}}==
Partial solution for simple continued fractions.
<
back(vector(100,i,2-(i==1)))</
Output:
<pre>%1 = 1.4142135623730950488016887242096980786</pre>
=={{header|Pascal}}==
This console application is written in Delphi, which allows the results to be displayed to 17 correct decimal places (Free Pascal seems to allow only 16). As in the jq solution, we aim to work forwards and stop as soon the desired precision has been reached, rather than guess a suitable number of terms and work backwards. In this program, the continued fraction is converted to an infinite sum, each term after the first being the difference between consecutive convergents. The convergence for pi is very slow (as others have noted) so as well as the c.f. in the task description an alternative is given from the Wikipedia article "Continued fraction".
<syntaxhighlight lang="pascal">
program ContFrac_console;
{$APPTYPE CONSOLE}
uses
SysUtils;
type TCoeffFunction = function( n : integer) : extended;
// Calculate continued fraction as a sum, working forwards.
// Stop on reaching a term with absolute value less than epsilon,
// or on reaching the maximum number of terms.
procedure CalcContFrac( a, b : TCoeffFunction;
epsilon : extended;
maxNrTerms : integer = 1000); // optional, with default
var
n : integer;
sum, term, u, v : extended;
whyStopped : string;
begin
sum := a(0);
term := b(1)/a(1);
v := a(1);
n := 1;
repeat
sum := sum + term;
inc(n);
u := v;
v := a(n) + b(n)/u;
term := -term * b(n)/(u*v);
until (Abs(term) < epsilon) or (n >= maxNrTerms);
if n >= maxNrTerms then whyStopped := 'too many terms'
else whyStopped := 'converged';
WriteLn( SysUtils.Format( '%21.17f after %d terms (%s)',
[sum, n, whyStopped]));
end;
//---------------- a and b for sqrt(2) ----------------
function a_sqrt2( n : integer) : extended;
begin
if n = 0 then result := 1
else result := 2;
end;
function b_sqrt2( n : integer) : extended;
begin
result := 1;
end;
//---------------- a snd b for e ----------------
function a_e( n : integer) : extended;
begin
if n = 0 then result := 2
else result := n;
end;
function b_e( n : integer) : extended;
begin
if n = 1 then result := 1
else result := n - 1;
end;
//-------- Rosetta Code a and b for pi --------
function a_pi( n : integer) : extended;
begin
if n = 0 then result := 3
else result := 6;
end;
function b_pi( n : integer) : extended;
var
temp : extended;
begin
temp := 2*n - 1;
result := temp*temp;
end;
//-------- More efficient a and b for pi --------
function a_pi_alt( n : integer) : extended;
begin
if n = 0 then result := 0
else result := 2*n - 1;
end;
function b_pi_alt( n : integer) : extended;
var
temp : extended;
begin
if n = 1 then
result := 4
else begin
temp := n - 1;
result := temp*temp;
end;
end;
//---------------- Main routine ----------------
// Unlike Free Pascal, Delphi does not require
// an @ sign before the function names.
begin
WriteLn( 'sqrt(2)');
CalcContFrac( a_sqrt2, b_sqrt2, 1E-20);
WriteLn( 'e');
CalcContFrac( a_e, b_e, 1E-20);
WriteLn( 'pi');
CalcContFrac( a_pi, b_pi, 1E-20);
WriteLn( 'pi (alternative formula)');
CalcContFrac( a_pi_alt, b_pi_alt, 1E-20);
end.
</syntaxhighlight>
{{out}}
<pre>
sqrt(2)
1.41421356237309505 after 27 terms (converged)
e
2.71828182845904524 after 20 terms (converged)
pi
3.14159265383979293 after 1000 terms (too many terms)
pi (alternative formula)
3.14159265358979324 after 29 terms (converged)
</pre>
=={{header|Perl}}==
Use closures to implement the infinite lists of coeffficients.
<
use warnings;
no warnings 'recursion';
Line 2,262 ⟶ 2,628:
printf "e ≈ %.9f\n", continued_fraction do { my $n; sub { $n++ or 2 } }, do { my $n; sub { $n++ or 1 } };
printf "π ≈ %.9f\n", continued_fraction do { my $n; sub { $n++ ? 6 : 3 } }, do { my $n; sub { (2*$n++ + 1)**2 } }, 1000;
printf "π/2 ≈ %.9f\n", continued_fraction do { my $n; sub { 1/($n++ or 1) } }, sub { 1 }, 1000;</
{{out}}
<pre>√2 ≈ 1.414213562
Line 2,270 ⟶ 2,636:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">precision</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10000</span>
Line 2,294 ⟶ 2,660:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Napier: %.10g\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">continued_fraction</span><span style="color: #0000FF;">(</span><span style="color: #000000;">nap</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Pi: %.10g\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">continued_fraction</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pi</span><span style="color: #0000FF;">)})</span>
<!--</
{{Out}}
<pre>
Line 2,306 ⟶ 2,672:
For Pi a test is added with a higher precision (200 -> 2000) to get a better result.
===Recursion===
{{trans|Prolog}}
<syntaxhighlight lang="picat">go =>
% square root 2
Line 2,351 ⟶ 2,718:
pi_ab(0, 3, _).
pi_ab(N, 6, V) :-
V is (2 * N - 1)*(2 * N - 1).</
{{out}}
<pre>
sqrt(2) = 1.414213562373095 (diff: 0.000000000000000)
Line 2,361 ⟶ 2,728:
</pre>
===Iterative===
{{trans|Python}}
(from Python's Fast Iterative version)
<syntaxhighlight lang="picat">continued_fraction_it(Fun, N) = Ret =>
Temp = 0.0,
foreach(I in N..-1..1)
Line 2,373 ⟶ 2,742:
fsqrt2(N) = [cond(N > 0, 2, 1),1].
fnapier(N) = [cond(N > 0, N,2), cond(N>1,N-1,1)].
fpi(N) = [cond(N>0,6,3), (2*N-1) ** 2].</
Which has exactly the same output as the recursive version.
=={{header|PicoLisp}}==
<
(de fsqrt2 (N A)
(default A 1)
Line 2,411 ⟶ 2,780:
(prinl (format (fsqrt2 200) *Scl))
(prinl (format (napier 200) *Scl))
(prinl (format (pi 200) *Scl))</
{{out}}
<pre>
Line 2,420 ⟶ 2,789:
=={{header|PL/I}}==
<
test: proc options (main);
declare n fixed;
Line 2,433 ⟶ 2,802:
put (1 + 1/denom(2));
end test;</
{{out}}
<pre> 1.41421356237309505E+0000 </pre>
Version for NAPIER:
<
declare n fixed;
Line 2,449 ⟶ 2,818:
put (2 + 1/denom(0));
end test;</
<pre> 2.71828182845904524E+0000 </pre>
Version for SQRT2, NAPIER, PI
<
continued_fractions: /* 6 Sept. 2012 */
Line 2,495 ⟶ 2,864:
put skip edit ('PI=', calc(pi, 99999)) (a(10), f(20,17));
end continued_fractions;</
{{out}}
<pre>
Line 2,504 ⟶ 2,873:
=={{header|Prolog}}==
<
% square root 2
continued_fraction(200, sqrt_2_ab, V1),
Line 2,546 ⟶ 2,915:
pi_ab(0, 3, _).
pi_ab(N, 6, V) :-
V is (2 * N - 1)*(2 * N - 1).</
{{out}}
<pre> ?- continued_fraction.
Line 2,557 ⟶ 2,926:
=={{header|Python}}==
{{works with|Python|2.6+ and 3.x}}
<
import itertools
try: zip = itertools.izip
Line 2,623 ⟶ 2,992:
cf = CF(Pi_a(), Pi_b(), 950)
print(pRes(cf, 10))
#3.1415926532</
===Fast iterative version===
{{trans|D}}
<
def calc(fun, n):
Line 2,649 ⟶ 3,018:
print calc(fsqrt2, 200)
print calc(fnapier, 200)
print calc(fpi, 200)</
{{out}}
<pre>1.4142135623730950488016887242096980785696718753770
Line 2,657 ⟶ 3,026:
=={{header|Quackery}}==
<
[ 1 min
Line 2,686 ⟶ 3,055:
1000 cf sqrt2 10 point$ echo$ cr
1000 cf napier 10 point$ echo$ cr
1000 cf pi 10 point$ echo$ cr</
{{out}}
Line 2,697 ⟶ 3,066:
===Using Doubles===
This version uses standard double precision floating point numbers:
<
#lang racket
(define (calc cf n)
Line 2,714 ⟶ 3,083:
(calc cf-napier 200)
(calc cf-pi 200)
</syntaxhighlight>
Output:
<
1.4142135623730951
2.7182818284590455
3.1415926839198063
</syntaxhighlight>
===Version - Using Doubles===
This versions uses big floats (arbitrary precision floating point):
<
#lang racket
(require math)
Line 2,744 ⟶ 3,113:
(calc cf-napier 200)
(calc cf-pi 200)
</syntaxhighlight>
Output:
<
(bf #e1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358960036439214262599769155193770031712304888324413327207659690547583107739957489062466508437105234564161085482146113860092820802430986649987683947729823677905101453725898480737256099166805538057375451207262441039818826744940289448489312217214883459060818483750848688583833366310472320771259749181255428309841375829513581694269249380272698662595131575038315461736928338289219865139248048189188905788104310928762952913687232022557677738108337499350045588767581063729)
(bf #e2.71828182845904523536028747135266249775724709369995957496696762772407663035354759457138217852516642742746639193200305992181741359662904357290033429526059563073813232862794349076323382988075319525101901157383418793070215408914993488416750924476146066808226480016847741185374234544243710753907774499206955170276183860626133138458300075204493382656029760673711320070932870912744374704723624212700454495421842219077173525899689811474120614457405772696521446961165559468253835854362096088934714907384964847142748311021268578658461064714894910680584249490719358138073078291397044213736982988247857479512745588762993966446075)
(bf #e3.14159268391980626493420192940831754203350026401337226640663040854412059241988978103217808449508253393479795573626200366332733859609651462659489470805432281782785922056335606047700127154963266242144951481397480765182268219697420028007903565511884267297358842935537138583640066772149177226656227031792115896439889412205871076985598822285367358003457939603015797225018209619662200081521930463480571130673429337524564941105654923909951299948539893933654293161126559643573974163405197696633200469475250152247413175932572922175467223988860975105100904322239324381097207835036465269418118204894206705789759765527734394105147)
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|rakudo|2015-10-31}}
<syntaxhighlight lang="raku"
{
my $x = @a[$n - 1];
Line 2,764 ⟶ 3,133:
printf "√2 ≈%.9f\n", continued-fraction(:a(1, |(2 xx *)), :b(Nil, |(1 xx *)));
printf "e ≈%.9f\n", continued-fraction(:a(2, |(1 .. *)), :b(Nil, 1, |(1 .. *)));
printf "π ≈%.9f\n", continued-fraction(:a(3, |(6 xx *)), :b(Nil, |((1, 3, 5 ... *) X** 2)));</
{{out}}
<pre>√2 ≈ 1.414213562
Line 2,781 ⟶ 3,150:
Raku has a builtin composition operator. We can use it with the triangular reduction metaoperator, and evaluate each resulting function at infinity (any value would do actually, but infinite makes it consistent with this particular task).
<syntaxhighlight lang="raku"
map { .(Inf) }, [\o] map { @a[$_] + @b[$_] / * }, ^Inf
}
Line 2,787 ⟶ 3,156:
printf "√2 ≈ %.9f\n", continued-fraction((1, |(2 xx *)), (1 xx *))[10];
printf "e ≈ %.9f\n", continued-fraction((2, |(1 .. *)), (1, |(1 .. *)))[10];
printf "π ≈ %.9f\n", continued-fraction((3, |(6 xx *)), ((1, 3, 5 ... *) X** 2))[100];</
{{out}}
<pre>√2 ≈ 1.414213552
Line 2,808 ⟶ 3,177:
More code is used for nicely formatting the output than the continued fraction calculation.
<
parse arg terms digs .
if terms=='' | terms=="," then terms=500
Line 2,850 ⟶ 3,219:
say right(?,8) "=" $ ' α terms='aT ...
if b.1\==1 then say right("",12+digits()) ' ß terms='bT ...
a=; b.=1; return /*only 50 bytes of α & ß terms ↑ are displayed. */</
'''output'''
<pre>
Line 2,898 ⟶ 3,267:
===version 2 derived from [[#PL/I|PL/I]]===
<
* Derived from PL/I with a little "massage"
* SQRT2= 1.41421356237309505 <- PL/I Result
Line 2,941 ⟶ 3,310:
end
call Get_Coeffs form, 0
return (A + Temp)</
===version 3 better approximation===
<
* The task description specifies a continued fraction for pi
* that gives a reasonable approximation.
Line 3,015 ⟶ 3,384:
end
call Get_Coeffs 0
return (A + Temp)</
=={{header|Ring}}==
<
# Project : Continued fraction
Line 3,037 ⟶ 3,406:
eval("temp3=" + expr + "1" + str)
return a0 + b1 / temp3
</syntaxhighlight>
Output:
<pre>
Line 3,043 ⟶ 3,412:
e = 2.718281828459046
PI = 3.141592653588017
</pre>
=={{header|RPL}}==
This task demonstrates how both global and local variables, arithmetic expressions and stack can be used together to build a compact and versatile piece of code.
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪
4 ROLL ROT → an bn
≪ 'N' STO 0 '''WHILE''' N 2 ≥ '''REPEAT'''
an + INV bn * EVAL
'N' 1 STO- '''END'''
an + / + EVAL
'N' PURGE
≫ ≫ ‘'''→CFRAC'''’ STO
|
'''→CFRAC''' ''( a0 an b1 bn N -- x ) ''
Unstack an and bn
Loop from N to 2
Calculate Nth fraction
Decrement counter
Calculate last fraction with b1 in stack, then add a0
Discard N variable - not mandatory but hygienic
|}
{{in}}
<pre>
1 2 1 1 100 →CFRAC
2 'N' 1 'N-1' 100 →CFRAC
3 6 1 '(2*N-1)^2' 1000 →CFRAC
1 1 1 1 100 →CFRAC
1 '2-MOD(N,2)' 1 1 100 →CFRAC
</pre>
{{out}}
<pre>
5: 1.41421356237
4: 2.71828182846
3: 3.14159265334
2: 1.61803398875
1: 1.73205080757
</pre>
=={{header|Ruby}}==
<
# square root of 2
Line 3,092 ⟶ 3,504:
puts estimate(sqrt2, 50).to_s('F')
puts estimate(napier, 50).to_s('F')
puts estimate(pi, 10).to_s('F')</
{{out}}
<pre>$ ruby cfrac.rb
Line 3,100 ⟶ 3,512:
=={{header|Rust}}==
<
use std::iter;
Line 3,146 ⟶ 3,558:
println!("{}", continued_fraction!(pia, pib));
}
</syntaxhighlight>
{{out}}
Line 3,158 ⟶ 3,570:
{{works with|Scala|2.9.1}}
Note that Scala-BigDecimal provides a precision of 34 digits. Therefore we take a limitation of 32 digits to avoiding rounding problems.
<
import Stream._
val sqrt2 = 1 #:: from(2,0) zip from(1,0)
Line 3,188 ⟶ 3,600:
println()
}
}</
{{out}}
<pre>sqrt2:
Line 3,205 ⟶ 3,617:
precision: 3.14159265358</pre>
For higher accuracy of pi we have to take more iterations. Unfortunately the foldRight function in calc isn't tail recursiv - therefore a stack overflow exception will be thrown for higher numbers of iteration, thus we have to implement an iterative way for calculation:
<
import Stream._
val sqrt2 = 1 #:: from(2,0) zip from(1,0)
Line 3,239 ⟶ 3,651:
println()
}
}</
{{out}}
<pre>sqrt2:
Line 3,259 ⟶ 3,671:
The following code relies on a library implementing SRFI 41 (lazy streams). Most Scheme interpreters include an implementation.
<
(import (rnrs base (6))
(srfi :41 streams))
Line 3,308 ⟶ 3,720:
(stream-cons 3
(stream-cycle (build-stream (lambda (n) (expt (- (* 2 (+ n 1)) 1) 2)))
(stream-constant 6))))</
Test:
<
1.4142135623730951
> (cf->real napier)
2.7182818284590455
> (cf->real pi)
3.141592653589794</
=={{header|Sidef}}==
<
f(func (r) {
r < n ? (a(r) / (b(r) + __FUNC__(r+1))) : 0
Line 3,335 ⟶ 3,747:
for k in (params.keys.sort) {
printf("%2s ≈ %s\n", k, continued_fraction(params{k}...))
}</
{{out}}
<pre>
Line 3,349 ⟶ 3,761:
{{trans|Rust}}
<
@inlinable
public func power(_ n: Self) -> Self {
Line 3,455 ⟶ 3,867:
print("π ≈ \(continuedFraction(piA, piB))")
</syntaxhighlight>
{{out}}
Line 3,462 ⟶ 3,874:
e ≈ 2.7182818284590455
π ≈ 3.141592653339042</pre>
{{trans|Java}}
<syntaxhighlight lang="swift">
import Foundation
func calculate(n: Int, operation: (Int) -> [Int])-> Double {
var tmp: Double = 0
for ni in stride(from: n, to:0, by: -1) {
var p = operation(ni)
tmp = Double(p[1])/(Double(p[0]) + tmp);
}
return Double(operation(0)[0]) + tmp;
}
func sqrt (n: Int) -> [Int] {
return [n > 0 ? 2 : 1, 1]
}
func napier (n: Int) -> [Int] {
var res = [n > 0 ? n : 2, n > 1 ? (n - 1) : 1]
return res
}
func pi(n: Int) -> [Int] {
var res = [n > 0 ? 6 : 3, Int(pow(Double(2 * n - 1), 2))]
return res
}
print (calculate(n: 200, operation: sqrt));
print (calculate(n: 200, operation: napier));
print (calculate(n: 200, operation: pi));
</syntaxhighlight>
=={{header|Tcl}}==
Line 3,467 ⟶ 3,912:
{{trans|Python}}
Note that Tcl does not provide arbitrary precision floating point numbers by default, so all result computations are done with IEEE <code>double</code>s.
<
# Term generators; yield list of pairs
Line 3,507 ⟶ 3,952:
puts [cf r2]
puts [cf e]
puts [cf pi 250]; # Converges more slowly</
{{out}}
<pre>1.4142135623730951
Line 3,514 ⟶ 3,959:
=={{header|VBA}}==
{{trans|Phix}}<
Private Function continued_fraction(steps As Integer, rid_a As String, rid_b As String) As Double
Dim res As Double
Line 3,553 ⟶ 3,998:
Debug.Print "Napier:", continued_fraction(precision, "nap_a", "nap_b")
Debug.Print "Pi:", continued_fraction(precision, "pi_a", "pi_b")
End Sub</
<pre>Precision: 10000
Sqr(2): 1,4142135623731
Line 3,561 ⟶ 4,006:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Function Calc(f As Func(Of Integer, Integer()), n As Integer) As Double
Dim temp = 0.0
Line 3,583 ⟶ 4,028:
End Sub
End Module</
{{out}}
<pre>1.4142135623731
Line 3,591 ⟶ 4,036:
=={{header|Wren}}==
{{trans|D}}
<
var t = 0
for (i in n..1) {
Line 3,605 ⟶ 4,050:
["pi ", Fn.new { |n| [(n > 0) ? 6 : 3, (2*n - 1) * (2*n - 1)] }]
]
for (p in pList) System.print("%(p[0]) = %(calc.call(p[1], 200))")</
{{out}}
Line 3,616 ⟶ 4,061:
=={{header|XPL0}}==
The number of iterations (N) needed to get the 13 digits of accuracy was determined by experiment.
<
int N;
real A, B, F;
Line 3,640 ⟶ 4,085:
RlOut(0, 3.0+F); CrLf(0);
RlOut(0, ACos(-1.0)); CrLf(0);
]</
{{out}}
<pre>
Line 3,655 ⟶ 4,100:
=={{header|zkl}}==
<
a0 + [n..1,-1].reduce(
'wrap(p,n){ fb(n)/(fa(n)+p) },0.0) }.fp(fa,fb,a0)
}</
cf creates a function that calculates the continued fraction from the bottom up. The new function takes a single parameter, n, which is used to calculate the nth term.
<
sqrt2(200) : "%.20e".fmt(_).println();
nap:=cf((0.0).create,fcn(n){ (n==1) and 1.0 or (n-1).toFloat() },2.0);
println(nap(15) - (1.0).e);
pi:=cf((6.0).noop,fcn(n){ n=2*n-1; (n*n).toFloat() },3.0);
println(pi(1000) - (1.0).pi);</
(1.0).create(n) --> n, (1.0).noop(n) --> 1.0
{{out}}
Line 3,676 ⟶ 4,121:
=={{header|ZX Spectrum Basic}}==
{{trans|BBC_BASIC}}
<
20 LET a0=2: LET b1=1: LET a$="N": LET b$="N": PRINT "e = ";: GO SUB 1000
30 LET a0=3: LET b1=1: LET a$="6": LET b$="(2*N+1)^2": PRINT "PI = ";: GO SUB 1000
Line 3,686 ⟶ 4,131:
1035 FOR i=1 TO n: LET p$=p$+")": NEXT i
1040 PRINT a0+b1/VAL (e$+"1"+p$)
1050 RETURN</
|