Golden ratio/Convergence: Difference between revisions
Realize in F#
(→{{header|Ruby}}: Add Ruby) |
(Realize in F#) |
||
| (22 intermediate revisions by 14 users not shown) | |||
Line 261:
<pre>Result: 1.618033 after 14 iterations
The error is approximately -1.201865E-06</pre>
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">precision 6
define i = 0, d = 0, phi0 = 1, phi1 = 0
do
let phi1 = 1 / phi0 + 1
let d = abs(phi1 - phi0)
let phi0 = phi1
let i = i + 1
wait
loopuntil .00001 > d
print "result: ", phi1, " after ", i, " iterations"
print "the error is approximately ", phi1 - (.5 * (1 + sqrt(5)))</syntaxhighlight>
{{out| Output}}<pre>result: 1.618033 after 14 iterations
the error is approximately -0.000001</pre>
==={{header|FreeBASIC}}===
Line 577 ⟶ 598:
Result: 1.618033 after 14 iterations
The error is approximately -0.000001
</pre>
=={{header|C#}}==
{{trans|Java}}
<syntaxhighlight lang="C#">
using System;
public class GoldenRatio {
static void Iterate() {
double oldPhi = 1.0, phi = 1.0, limit = 1e-5;
int iters = 0;
while (true) {
phi = 1.0 + 1.0 / oldPhi;
iters++;
if (Math.Abs(phi - oldPhi) <= limit) break;
oldPhi = phi;
}
Console.WriteLine($"Final value of phi : {phi:0.00000000000000}");
double actualPhi = (1.0 + Math.Sqrt(5.0)) / 2.0;
Console.WriteLine($"Number of iterations : {iters}");
Console.WriteLine($"Error (approx) : {phi - actualPhi:0.00000000000000}");
}
public static void Main(string[] args) {
Iterate();
}
}
</syntaxhighlight>
{{out}}
<pre>
Final value of phi : 1.61803278688525
Number of iterations : 14
Error (approx) : -0.00000120186465
</pre>
Line 732 ⟶ 787:
</syntaxhighlight>
=={{header|EDSAC order code}}==
By working with 1 - phi_n instead of phi_n, we bring the values into the EDSAC range [-1,1) without a change of scale.
<syntaxhighlight lang="edsac">
[GoldenRatio/Convergence for Rosetta Code.
EDSAC program, Initial Orders 2]
[-----------------------------------------------------------------
Given phi_n as in the task description, let u_n = 1 - phi_n.
Then u_0 = 0 and the recurrence is u_(n+1) = 1/(u_n - 1).
To keep the arguments of the division subroutine D6 within range,
the recurrence is calculated as u_(n+1) = (1/4)/(u_n/4 - 1/4).
-----------------------------------------------------------------]
[Arrange the storage]
T47K P300F [M parameter: main routine]
T48K P56F [& (Delta) parameter: library s/r D6 (division)]
T49K P92F [L parameter: library s/r P1 (prints real)]
T50K P200F [X parameter: library s/r P7 (prints integer)]
[--------------------------------------------------------------------------
Library subroutine R2, reads values as positive integers at load time,
and is then overwritten.]
GKT20FVDL8FA40DUDTFI40FA40FS39FG@S2FG23FA5@T5@E4@E13Z
T#M [tell R2 where to store values]
[Values when interpreted as reals are 1/4, 0.00001, -0.6180339887]
4294967296F171799F23741995290#TZ
[--------------------------------------------------------------------------
[Library subroutine M3, prints header at load time, and is then overwritten.
Here, last character sets teleprinter to figures.]
PFGKIFAFRDLFUFOFE@A6FG@E8FEZPF
*AIMING!AT!#1!A!*PHI@&ITERATIONS!!!FINAL!VALUE!!!!!ABS!ERROR@&#..
PK [after header, blank tape and PK (WWG, 1951, page 91)]
[--------------------------------------------------------------------------
M parameter: Main routine]
E25K TM GK
[Constants read in by R2 are stored here]
[0] [1/4]
[2] [0.00001, test for convergence]
[4] [limit as adapted for EDSAC, (1 - sqrt(5))/2 = -0.618...]
T6Z [don't overwrite constants: load from relative location 6]
[6] PF PF [current term]
[8] PF PF [previous term]
[10] PF [number of iterations, right justified]
[11] PD [17-bit constant 1]
[Enter here with acc = 0]
[12] T6#@ [u_0 := 0]
T10@ [count of iterations := 0]
[Loop to get next term]
[14] TF [clear acc]
A10@ A11@ T10@ [inc number of iterations]
A#@ TD [0D := 1/4 for division subroutine]
A6#@ U8#@ [previous term := current term u_n]
R1F [shift 2 right, acc := u_n/4]
S#@ T4D [4D := u_n/4 - 1/4 for division subroutine]
A25@ G& [call dvision s/r, 0D := u_(n+1)]
AD U6#@ [store u_(n+1)]
S8#@ E33@ [acc := u_(n+1) - u_n, skip if >= 0]
T4D S4D [else negate to get absolute difference]
[33] S2#@ [test for convergence]
E14@ [loop back if not converged]
[Here when converged]
TF TD [clear acc and whole of 0D (including sandwich bit)]
A10@ TF [0D := count of iterations, extended to 35 bits]
A39@ GX O79@ [print count and space]
A6#@ TD [final value to 0D for printing]
A44@ G59@ O79@ [print value and space]
A4#@ S6#@ E52@ [acc := error, skip if >= 0]
TD SD [else negate to get absolute value]
[52] TD [absolute error to 0D for printing]
A53@ G59@ O80@ O81@ [print error and new line]
O82@ [print null to flush teleprinter buffer]
ZF [halt machine]
[----------------------------------------------------------------------------
Wrapper for library subroutine P1. Adds '0.' before the decimal part,
preceded by space or minus sign.]
[59] A3F T76@ [plant return link as usual]
[61] AD G65@ [acc := number to print; jump if < 0]
O79@ E68@ [write space, join common code]
[65] TD SD [acc := number negated]
O61@ [write minus sign]
[68] YF YF [rounding: add 2^-34, nearest possible to 0.5*(10^-10)]
O77@ O78@ [print '0.']
TD [pass value to print subroutine]
A73@ GL P10F [call P1, print 10 decimals]
[76] ZF [(planted) jump back to caller]
[77] PF [digit '0' in figures mode]
[78] MF [full stop, here used for decimal point]
[79] !F [space]
[80] @F [carriage return]
[81] &F [line feed]
[82] K4096F [null char]
[--------------------------------------------------------------------------
Library subroutine P1: prints non-negative fraction in 0D, without '0.']
E25K TL
GKA18@U17@S20@T5@H19@PFT5@VDUFOFFFSFL4FTDA5@A2FG6@EFU3FJFM1F
[--------------------------------------------------------------------------
Library subroutine P7, prints long strictly positive integer;
10 characters, right justified, padded left with spaces.
Even address; 35 storage locations; working position 4D.]
E25K TX
GKA3FT26@H28#@NDYFLDT4DS27@TFH8@S8@T1FV4DAFG31@SFLDUFOFFFSF
L4FT4DA1FA27@G11@XFT28#ZPFT27ZP1024FP610D@524D!FO30@SFL8FE22@
[--------------------------------------------------------------------------
Library subroutine D6: Division, accurate, fast.
0D := 0D/4D, where 4D <> 0, -1.
36 locations, working positons 6D and 8D.]
E25K T&
GKA3FT34@S4DE13@T4DSDTDE2@T4DADLDTDA4DLDE8@RDU4DLD
A35@T6DE25@U8DN8DA6DT6DH6DS6DN4DA4DYFG21@SDVDTDEFW1526D
[--------------------------------------------------------------------------
M parameter again: define entry point]
E25K TM GK
E12Z
PF [enter with acc = 0]
</syntaxhighlight>
{{out}}
<pre>
AIMING AT 1 - PHI
ITERATIONS FINAL VALUE ABS ERROR
14 -0.6180327869 0.0000012019
</pre>
=={{header|F_Sharp|F#}}==
This task uses code from [https://rosettacode.org/wiki/Continued_fraction#F# Continued fraction(F#)]
<syntaxhighlight lang="fsharp">
// Golden ratio/Convergence. Nigel Galloway: March 8th., 2024
let ϕ=let aπ()=fun()->1M in cf2S(aπ())(aπ())
let (_,n),g=let mutable l=1 in (ϕ|>Seq.pairwise|>Seq.skipWhile(fun(n,g)->l<-l+1;abs(n-g)>1e-5M)|>Seq.head,l)
printfn "Value of ϕ is %1.14f after %d iterations error with respect to (1+√5)/2 is %1.14f" n g (abs(n-(decimal(1.0+(sqrt 5.0))/2M)))
</syntaxhighlight>
{{out}}
<pre>
Value of ϕ is 1.61803278688525 after 14 iterations error with respect to (1+√5)/2 is 0.00000120186465
</pre>
=={{header|Fortran}}==
==={{header|Fortran77}}===
Line 917 ⟶ 1,103:
14 iterations
The error is approximately -1.201864649e-06</pre>
=={{header|J}}==
(Using IEEE754 64 bit binary floating point, of course):
<syntaxhighlight lang=J> (,({:p)-~{&p)>:1 i.~1e_5>:|2 -/\p=. 1&(+%)^:a:1 NB. iterations and error
14 _1.20186e_6</syntaxhighlight>
In other words, wait for the series to converge (32 iterations - a few microseconds), check the pairwise differences and calculate the discrepancy.
=={{header|jq}}==
Line 991 ⟶ 1,185:
Number of iterations : 14
Error (approx) : -0.00000120186465
</pre>
=={{header|Julia}}==
{{trans|Wren}}
<syntaxhighlight lang="julia">function iterate_phi(limit::T) where T <: Real
phi, oldphi, iters = one(limit), one(limit), 0
while true
phi = 1 + 1 / oldphi
iters += 1
abs(phi - oldphi) <= limit && break
oldphi = phi
end
println("Final value of phi : $phi")
println("Number of iterations : $iters")
println("Error (approx) : $(phi - (1 + sqrt(T(5))) / 2)")
end
iterate_phi(1 / 10^5)
iterate_phi(1 / big(10)^25)
</syntaxhighlight>{{out}}
<pre>
Final value of phi : 1.6180327868852458
Number of iterations : 14
Error (approx) : -1.2018646491362972e-6
Final value of phi : 1.618033988749894848204586861593755309455975426621472923229332700794030300052916
Number of iterations : 61
Error (approx) : 2.722811719173566624681571006109388407808876983723400587864054809516456794284321e-26
</pre>
=={{header|Lua}}==
<syntaxhighlight lang="lua">local phi, phi0, expected, iters = 1, 0, (1 + math.sqrt(5)) / 2, 0
repeat
phi0, phi = phi, 1 + 1 / phi
iters = iters + 1
until math.abs(phi0 - phi) < 1e-5
io.write( "after ", iters, " iterations, phi = ", phi )
io.write( ", expected value: ", expected, ", diff: ", math.abs( expected - phi ), "\n" )
</syntaxhighlight>
{{out}}
<pre>after 14 iterations, phi = 1.6180327868852, expected value: 1.6180339887499, diff: 1.2018646491363e-06
</pre>
Line 1,112 ⟶ 1,346:
<pre>Result: 1.6180327868852458 after 14 iterations
The error is approximately -1.2018646491362972e-06
</pre>
=={{header|Nim}}==
<syntaxhighlight lang="Nim">import std/strutils
iterator goldenRatio(): (int, float) =
var phi = 1.0
var idx = 0
while true:
yield (idx, phi)
phi = 1 + 1 / phi
inc idx
const Eps = 1e-5
const Phi = 1.6180339887498948482045868343656381177203091798057628621354486
var prev = 0.0
for (i, phi) in goldenRatio():
if abs(phi - prev) <= Eps:
echo "Final value of φ: ", phi
echo "Number of iterations: ", i
echo "Approximative error: ", formatFloat(phi - Phi, ffDecimal)
break
prev = phi
</syntaxhighlight>
{{out}}
<pre>Final value of φ: 1.618032786885246
Number of iterations: 14
Approximative error: -0.0000012018646491</pre>
=={{header|Odin}}==
<syntaxhighlight lang="Go">
package golden
import "core:fmt"
import "core:math"
/* main block */
main :: proc() {
iterate()
}
/* definitions */
iterate :: proc() {
count := 0
phi0: f64 = 1.0
difference: f64 = 1.0
phi1: f64
fmt.println("\nGolden ratio/Convergence")
fmt.println("-----------------------------------------")
for 1.0e-5 < difference {
phi1 = 1.0 + (1.0 / phi0)
difference = abs(phi1 - phi0)
phi0 = phi1
count += 1
fmt.printf("Iteration %2d : Estimate : %.8f\n", count, phi1)
}
fmt.println("-----------------------------------------")
fmt.printf("Result: %.8f after %d iterations", phi1, count)
fmt.printf("\nThe error is approximately %.10f\n", (phi1 - (0.5 * (1.0 + math.sqrt_f64(5.0)))))
}
</syntaxhighlight>
{{out}}
<pre>
Golden ratio/Convergence
-----------------------------------------
Iteration 01 : Estimate : 2.00000000
Iteration 02 : Estimate : 1.50000000
Iteration 03 : Estimate : 1.66666667
Iteration 04 : Estimate : 1.60000000
Iteration 05 : Estimate : 1.62500000
Iteration 06 : Estimate : 1.61538462
Iteration 07 : Estimate : 1.61904762
Iteration 08 : Estimate : 1.61764706
Iteration 09 : Estimate : 1.61818182
Iteration 10 : Estimate : 1.61797753
Iteration 11 : Estimate : 1.61805556
Iteration 12 : Estimate : 1.61802575
Iteration 13 : Estimate : 1.61803714
Iteration 14 : Estimate : 1.61803279
-----------------------------------------
Result: 1.61803279 after 14 iterations
The error is approximately -0.0000012019
</pre>
Line 1,174 ⟶ 1,489:
<pre>Result: 987/610 (1.618032786) after 14 iterations
The error is approximately -0.000001202</pre>
=={{header|Onyx (wasm)}}==
<syntaxhighlight lang="TS">
package main
use core {*}
use core.math{abs}
use core.intrinsics.wasm{sqrt_f64}
main :: () {
iterate();
}
iterate :: () {
count := 0;
phi0: f64 = 1.0;
difference: f64 = 1.0;
phi1: f64;
println("\nGolden ratio/Convergence");
println("-----------------------------------------");
while 0.00001 < difference {
phi1 = 1.0 + (1.0 / phi0);
difference = abs(phi1 - phi0);
phi0 = phi1;
count += 1;
printf("Iteration {} : Estimate : {.8}\n", count, phi1);
}
println("-----------------------------------------");
printf("Result: {} after {} iterations", phi1, count);
printf("\nThe error is approximately {.8}\n", (phi1 - (0.5 * (1.0 + sqrt_f64(5.0)))));
println("\n");
}
</syntaxhighlight>
{{out}}
<pre>
Golden ratio/Convergence
-----------------------------------------
Iteration 1 : Estimate : 2.00000000
Iteration 2 : Estimate : 1.50000000
Iteration 3 : Estimate : 1.66666666
Iteration 4 : Estimate : 1.60000000
Iteration 5 : Estimate : 1.62500000
Iteration 6 : Estimate : 1.61538461
Iteration 7 : Estimate : 1.61904761
Iteration 8 : Estimate : 1.61764705
Iteration 9 : Estimate : 1.61818181
Iteration 10 : Estimate : 1.61797752
Iteration 11 : Estimate : 1.61805555
Iteration 12 : Estimate : 1.61802575
Iteration 13 : Estimate : 1.61803713
Iteration 14 : Estimate : 1.61803278
-----------------------------------------
Result: 1.6180 after 14 iterations
The error is approximately -0.00000120
</pre>
=={{header|ooRexx}}==
Line 1,201 ⟶ 1,568:
Error (approx) : -0.000001201864649
Number of iterations: 14
</pre>
=={{header|Perl}}==
<syntaxhighlight lang="perl" line>
use strict; use warnings;
use constant phi => (1 + sqrt 5) / 2;
sub GR { my $n = shift; $n == 1 ? 2 : 1 + 1 / GR($n - 1) }
my $i;
while (++$i) {
my $dev = abs phi - GR($i);
(printf "%d iterations: %8.6f vs %8.6f (%8.6f)\n", $i, phi, GR($i), $dev and last) if $dev < 1e-5;
}
</syntaxhighlight>
{{out}}
<pre>
12 iterations: 1.618034 vs 1.618026 (0.000008)
</pre>
Line 1,285 ⟶ 1,670:
</pre>
=={{header|
<syntaxhighlight lang="raku">constant phi = 1.FatRat, 1 + 1/* ... { abs($^a-$^b)≤1e-5 };
Line 1,469 ⟶ 1,854:
I ran this with shen-scheme.
<pre>[1.6180327868852458 14 -1.2018646493583418e-6]</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">const phi = (1+sqrt(5))/2
func GR(n) is cached { (n == 1) ? 1 : (1 + 1/__FUNC__(n-1)) }
var n = (1..Inf -> first {|n|
abs(GR(n) - GR(n+1)) <= 1e-5
})
say "#{n} iterations: #{GR(n+1)} (cfrac)\n#{' '*15}#{phi} (actual)"
say "The error is: #{GR(n+1) - phi}"</syntaxhighlight>
{{out}}
<pre>
14 iterations: 1.6180327868852459016393442622950819672131147541 (cfrac)
1.61803398874989484820458683436563811772030917981 (actual)
The error is: -0.00000120186464894656524257207055615050719442570740221
</pre>
=={{header|V (Vlang)}}==
Line 1,503 ⟶ 1,905:
{{libheader|Wren-fmt}}
Wren's only built-in numeric type is a 64 bit float.
<syntaxhighlight lang="
var oldPhi = 1
| |||