Rosetta Code

Feigenbaum constant calculation: Difference between revisions

← Older edit
Content deleted Content added
Robbie (talk | contribs)
1,452 edits
Zeddicus (talk | contribs)
108 edits
 
(60 intermediate revisions by 31 users not shown)
Line 1:
{{draft task}}
 
 
;Task:
Line 9 ⟶ 8:
:*   Details in the Wikipedia article:   [https://en.wikipedia.org/wiki/Feigenbaum_constants Feigenbaum constant].
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">V max_it = 13
V max_it_j = 10
V a1 = 1.0
V a2 = 0.0
V d1 = 3.2
V a = 0.0
 
print(‘ i d’)
L(i) 2..max_it
a = a1 + (a1 - a2) / d1
L(j) 1..max_it_j
V x = 0.0
V y = 0.0
L(k) 1..(1 << i)
y = 1.0 - 2.0 * y * x
x = a - x * x
a = a - x / y
V d = (a1 - a2) / (a - a1)
print(‘#2 #.8’.format(i, d))
d1 = d
a2 = a1
a1 = a</syntaxhighlight>
 
{{out}}
<pre>
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|Ada}}==
{{Trans|Ring}}
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
 
procedure Main is
procedure feigenbaum is
subtype i_range is Integer range 2 .. 13;
subtype j_range is Integer range 1 .. 10;
 
-- the number of digits in type Real is reduced to 15 to produce the
-- results reported by C, C++, C# and Ring. Increasing the number of
-- digits in type Real produces the results reported by D.
 
type Real is digits 15;
package Real_Io is new Float_IO (Real);
use Real_Io;
 
a, x, y, d : Real;
a1 : Real := 1.0;
a2 : Real := 0.0;
d1 : Real := 3.2;
begin
Put_Line (" i d");
for i in i_range loop
a := a1 + (a1 - a2) / d1;
for j in j_range loop
x := 0.0;
y := 0.0;
for k in 1 .. 2**i loop
y := 1.0 - 2.0 * x * y;
x := a - x * x;
end loop;
a := a - x / y;
end loop;
d := (a1 - a2) / (a - a1);
Put (Item => i, Width => 2);
Put (Item => d, Fore => 5, Aft => 8, Exp => 0);
New_Line;
d1 := d;
a2 := a1;
a1 := a;
end loop;
end feigenbaum;
 
begin
feigenbaum;
end Main;
</syntaxhighlight>
{{out}}
<pre>
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
{{Trans|Ring}}
<syntaxhighlight lang="algol68"># Calculate the Feigenbaum constant #
print( ( "Feigenbaum constant calculation:", newline ) );
INT max it = 13;
INT max it j = 10;
REAL a1 := 1.0;
REAL a2 := 0.0;
REAL d1 := 3.2;
print( ( "i ", "d", newline ) );
FOR i FROM 2 TO max it DO
REAL a := a1 + (a1 - a2) / d1;
FOR j TO max it j DO
REAL x := 0;
REAL y := 0;
FOR k TO 2 ^ i DO
y := 1 - 2 * y * x;
x := a - x * x
OD;
a := a - x / y
OD;
REAL d = (a1 - a2) / (a - a1);
IF i < 10 THEN
print( ( whole( i, 0 ), " ", fixed( d, -10, 8 ), newline ) )
ELSE
print( ( whole( i, 0 ), " ", fixed( d, -10, 8 ), newline ) )
FI;
d1 := d;
a2 := a1;
a1 := a
OD</syntaxhighlight>
{{out}}
<pre>
Feigenbaum constant calculation:
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f FEIGENBAUM_CONSTANT_CALCULATION.AWK
BEGIN {
Line 38 ⟶ 198:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 55 ⟶ 215:
13 4.66920537
</pre>
 
=={{header|BASIC}}==
==={{header|BASIC256}}===
<syntaxhighlight lang="freebasic">maxIt = 13 : maxItj = 13
a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2
 
print "Feigenbaum constant calculation:"
print
print " i d"
print "======================"
 
for i = 2 to maxIt
a = a1 + (a1 - a2) / d1
for j = 1 to maxItj
x = 0.0 : y = 0.0
for k = 1 to 2 ^ i
y = 1 - 2 * y * x
x = a - x * x
next k
a -= x / y
next j
d = (a1 - a2) / (a - a1)
print rjust(i,3); chr(9); ljust(d,13,"0")
d1 = d
a2 = a1
a1 = a
next i</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">100 cls
110 mit = 13
120 mitj = 13
130 a1 = 1
140 a2 = 0
150 d = 0
160 d1 = 3.2
170 print "Feigenbaum constant calculation:"
180 print
190 print " i d"
200 print "==================="
210 for i = 2 to mit
220 a = a1+(a1-a2)/d1
230 for j = 1 to mitj
240 x = 0
250 y = 0
260 for k = 1 to 2^i
270 y = 1-2*y*x
280 x = a-x*x
290 next k
300 a = a-(x/y)
310 next j
320 d = (a1-a2)/(a-a1)
330 print using "###";i;" ";
335 print using "##.#########";d
340 d1 = d
350 a2 = a1
360 a1 = a
370 next i
380 end</syntaxhighlight>
 
==={{header|Just BASIC}}===
<syntaxhighlight lang="lb">maxit = 13 : maxitj = 13
a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2
 
print "Feigenbaum constant calculation:"
print
print " i d"
print "==================="
 
for i = 2 to maxit
a = a1 + (a1 - a2) / d1
for j = 1 to maxitj
x = 0 : y = 0
for k = 1 to 2 ^ i
y = 1 - 2 * y * x
x = a - x * x
next k
a = a - (x / y)
next j
d = (a1 - a2) / (a - a1)
print i; tab(8); d
d1 = d
a2 = a1
a1 = a
next i</syntaxhighlight>
 
==={{header|MSX Basic}}===
{{works with|MSX BASIC|any}}
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">100 CLS
110 mit = 13
120 mitj = 13
130 a1 = 1
140 a2 = 0
150 d = 0
160 d1 = 3.2
170 PRINT "Feigenbaum constant calculation:"
180 PRINT
190 PRINT " i d"
200 PRINT "==================="
210 FOR i = 2 TO mit
220 a = a1 + (a1 - a2) / d1
230 FOR j = 1 TO mitj
240 x = 0
250 y = 0
260 FOR k = 1 TO 2 ^ i
270 y = 1 - 2 * y * x
280 x = a - x * x
290 NEXT k
300 a = a - (x / y)
310 NEXT j
320 d = (a1 - a2) / (a - a1)
330 PRINT USING "### ##.#########"; i; d
340 d1 = d
350 a2 = a1
360 a1 = a
370 NEXT i
380 END</syntaxhighlight>
 
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">LET maxit = 13
LET maxitj = 13
LET a1 = 1.0
LET d1 = 3.2
 
PRINT "Feigenbaum constant calculation:"
PRINT
PRINT " i d"
PRINT "==================="
 
FOR i = 2 to maxit
LET a = a1 + (a1 - a2) / d1
FOR j = 1 to maxitj
LET x = 0
LET y = 0
FOR k = 1 to 2 ^ i
LET y = 1 - 2 * y * x
LET x = a - x * x
NEXT k
LET a = a - (x / y)
NEXT j
LET d = (a1 - a2) / (a - a1)
PRINT using "### ##.#########": i, d
LET d1 = d
LET a2 = a1
LET a1= a
NEXT i
END</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|Yabasic}}===
<syntaxhighlight lang="freebasic">maxIt = 13 : maxItj = 13
a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2
 
print "Feigenbaum constant calculation:"
print "\n i d"
print "===================="
 
for i = 2 to maxIt
a = a1 + (a1 - a2) / d1
for j = 1 to maxItj
x = 0.0 : y = 0.0
for k = 1 to 2 ^ i
y = 1 - 2 * y * x
x = a - x * x
next k
a = a - x / y
next j
d = (a1 - a2) / (a - a1)
print i using("###"), chr$(9), d
d1 = d
a2 = a1
a1 = a
next i</syntaxhighlight>
 
=={{header|C}}==
{{trans|Ring}}
<langsyntaxhighlight lang="c">#include <stdio.h>
 
void feigenbaum() {
Line 85 ⟶ 425:
feigenbaum();
return 0;
}</langsyntaxhighlight>
 
{{output}}
Line 104 ⟶ 444:
</pre>
 
=={{header|C++ sharp|C#}}==
{{trans|C}}
<lang cpp>#include <iostream>
 
int main() {
const int max_it = 13;
const int max_it_j = 10;
double a1 = 1.0, a2 = 0.0, d1 = 3.2;
 
std::cout << " i d\n";
for (int i = 2; i <= max_it; ++i) {
double a = a1 + (a1 - a2) / d1;
for (int j = 1; j <= max_it_j; ++j) {
double x = 0.0;
double y = 0.0;
for (int k = 1; k <= 1 << i; ++k) {
y = 1.0 - 2.0*y*x;
x = a - x * x;
}
a -= x / y;
}
double d = (a1 - a2) / (a - a1);
printf("%2d %.8f\n", i, d);
d1 = d;
a2 = a1;
a1 = a;
}
 
return 0;
}</lang>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|C#|C sharp}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="csharp">using System;
 
namespace FeigenbaumConstant {
Line 181 ⟶ 476:
}
}
}</langsyntaxhighlight>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|C++}}==
{{trans|C}}
<syntaxhighlight lang="cpp">#include <iostream>
 
int main() {
const int max_it = 13;
const int max_it_j = 10;
double a1 = 1.0, a2 = 0.0, d1 = 3.2;
 
std::cout << " i d\n";
for (int i = 2; i <= max_it; ++i) {
double a = a1 + (a1 - a2) / d1;
for (int j = 1; j <= max_it_j; ++j) {
double x = 0.0;
double y = 0.0;
for (int k = 1; k <= 1 << i; ++k) {
y = 1.0 - 2.0*y*x;
x = a - x * x;
}
a -= x / y;
}
double d = (a1 - a2) / (a - a1);
printf("%2d %.8f\n", i, d);
d1 = d;
a2 = a1;
a1 = a;
}
 
return 0;
}</syntaxhighlight>
{{out}}
<pre> i d
Line 198 ⟶ 538:
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio;
 
void main() {
Line 226 ⟶ 566:
a1 = a;
}
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 241 ⟶ 581:
12 4.66920099
13 4.66920555</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Translated from Algol
<syntaxhighlight lang="Delphi">
 
 
procedure FeigenbaumConstant(Memo: TMemo);
{ Calculate the Feigenbaum constant }
const IMax = 13;
const JMax = 10;
var I,J,K: integer;
var A1,A2,D1,X,Y: double;
var A,D: double;
begin
Memo.Lines.Add('Feigenbaum constant calculation:');
{Set initial starting values for iterations}
A1:=1.0; A2:=0.0; D1:=3.2;
Memo.Lines.Add(' I A D');
for I:=2 to IMax do
begin
{Find next Bifurcation parameter, A}
A:=A1 + (A1 - A2) / D1;
for J:=1 to JMax do
begin
X:=0; Y:=0;
for K:=1 to 1 shl i do
begin
Y:=1 - 2 * y * x;
X:=A - X * X
end;
A:=A - X / Y
end;
{Use current and previous values of A}
{to calculate the Feigenbaum constant D }
D:= (A1 - A2) / (A - A1);
Memo.Lines.Add(Format('%2d %2.8f %2.8f',[I,A,D]));
D1:=D; A2:=A1; A1:=A;
end;
end;
 
</syntaxhighlight>
{{out}}
<pre>
Feigenbaum constant calculation:
I A D
2 1.31070264 3.21851142
3 1.38154748 4.38567760
4 1.39694536 4.60094928
5 1.40025308 4.65513050
6 1.40096196 4.66611195
7 1.40111380 4.66854858
8 1.40114633 4.66906066
9 1.40115329 4.66917155
10 1.40115478 4.66919515
11 1.40115510 4.66920028
12 1.40115517 4.66920099
13 1.40115519 4.66920555
</pre>
 
=={{header|EasyLang}}==
{{trans|AWK}}
<syntaxhighlight>
numfmt 6 0
a1 = 1 ; a2 = 0 ; d1 = 3.2
ipow2 = 4
for i = 2 to 13
a = a1 + (a1 - a2) / d1
for j = 1 to 10
x = 0 ; y = 0
for k = 1 to ipow2
y = 1 - 2 * y * x
x = a - x * x
.
a -= x / y
.
d = (a1 - a2) / (a - a1)
print i & " " & d
d1 = d ; a2 = a1 ; a1 = a
ipow2 *= 2
.
</syntaxhighlight>
 
=={{header|F#|F sharp}}==
{{trans|C#}}
<syntaxhighlight lang="fsharp">open System
 
[<EntryPoint>]
let main _ =
let maxIt = 13
let maxItJ = 10
let mutable a1 = 1.0
let mutable a2 = 0.0
let mutable d1 = 3.2
Console.WriteLine(" i d")
for i in 2 .. maxIt do
let mutable a = a1 + (a1 - a2) / d1
for j in 1 .. maxItJ do
let mutable x = 0.0
let mutable y = 0.0
for _ in 1 .. (1 <<< i) do
y <- 1.0 - 2.0 * y * x
x <- a - x * x
a <- a - x / y
let d = (a1 - a2) / (a - a1)
Console.WriteLine("{0,2:d} {1:f8}", i, d)
d1 <- d
a2 <- a1
a1 <- a
0 // return an integer exit code</syntaxhighlight>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|Factor}}==
{{trans|Raku}}
<syntaxhighlight lang="factor">USING: formatting io locals math math.ranges sequences ;
 
[let
1 :> a1!
0 :> a2!
3.2 :> d!
 
" i d" print
 
2 13 [a,b] [| exp |
a1 a2 - d /f a1 + :> a!
10 [
0 :> x!
0 :> y!
exp 2^ [
1 2 x y * * - y!
a x sq - x!
] times
a x y /f - a!
] times
a1 a2 - a a1 - /f d!
a1 a2! a a1!
exp d "%2d %.8f\n" printf
] each
]</syntaxhighlight>
{{out}}
<pre>
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|Fortran}}==
<syntaxhighlight lang="fortran"> program feigenbaum
implicit none
 
integer i, j, k
real ( KIND = 16 ) x, y, a, b, a1, a2, d1
 
print '(a4,a13)', 'i', 'd'
 
a1 = 1.0;
a2 = 0.0;
d1 = 3.2;
 
do i=2,20
a = a1 + (a1 - a2) / d1;
do j=1,10
x = 0
y = 0
do k=1,2**i
y = 1 - 2 * y * x;
x = a - x**2;
end do
a = a - x / y;
end do
 
d1 = (a1 - a2) / (a - a1);
a2 = a1;
a1 = a;
print '(i4,f13.10)', i, d1
end do
end</syntaxhighlight>
{{out}}
<pre> i d
2 3.2185114220
3 4.3856775986
4 4.6009492765
5 4.6551304954
6 4.6661119478
7 4.6685485814
8 4.6690606606
9 4.6691715554
10 4.6691951560
11 4.6692002291
12 4.6692013133
13 4.6692015458
14 4.6692015955
15 4.6692016062
16 4.6692016085
17 4.6692016090
18 4.6692016091
19 4.6692016091
20 4.6692016091</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' version 25-0-2019
' compile with: fbc -s console
 
Dim As UInteger i, j, k, maxit = 13, maxitj = 13
Dim As Double x, y, a, a1 = 1, a2, d, d1 = 3.2
 
Print "Feigenbaum constant calculation:"
Print
Print " i d"
Print "==================="
 
For i = 2 To maxIt
a = a1 + (a1 - a2) / d1
For j = 1 To maxItJ
x = 0 : y = 0
For k = 1 To 2 ^ i
y = 1 - 2 * y * x
x = a - x * x
Next
a = a - x / y
Next
d = (a1 - a2) / (a - a1)
Print Using "### ##.#########"; i; d
d1 = d
a2 = a1
a1 = a
Next
 
' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End</syntaxhighlight>
{{out}}
<pre>Feigenbaum constant calculation:
 
i d
===================
2 3.218511422
3 4.385677599
4 4.600949277
5 4.655130495
6 4.666111948
7 4.668548581
8 4.669060660
9 4.669171555
10 4.669195148
11 4.669200285
12 4.669201301
13 4.669198656</pre>
 
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Feigenbaum_constant_calculation}}
 
'''Solution'''
 
[[File:Fōrmulæ - Feigenbaum constant calculation 01.png]]
 
'''Test case'''
 
[[File:Fōrmulæ - Feigenbaum constant calculation 02.png]]
 
[[File:Fōrmulæ - Feigenbaum constant calculation 03.png]]
 
=={{header|FutureBasic}}==
{{trans|Ring and Phix}}
<syntaxhighlight lang="futurebasic">
window 1, @"Feignenbaum Constant", ( 0, 0, 200, 300 )
 
_maxIt = 13
_maxItJ = 10
 
void local fn Feignenbaum
NSUInteger i, j, k
double a1 = 1.0, a2 = 0.0, d1 = 3.2
print "Feignenbaum Constant"
print " i d"
for i = 2 to _maxIt
double a = a1 + ( a1 - a2 ) / d1
for j = 1 to _maxItJ
double x = 0, y = 0
for k = 1 to fn pow( 2, i )
y = 1 - 2 * y * x
x = a - x * x
next
a = a - x / y
next
double d = ( a1 - a2 ) / ( a - a1 )
printf @"%2d. %.8f", i, d
d1 = d
a2 = a1
a1 = a
next
end fn
 
fn Feignenbaum
 
HandleEvents
</syntaxhighlight>
 
{{out}}
<pre>
Feignenbaum Constant
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|Go}}==
{{trans|Ring}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 270 ⟶ 954:
func main() {
feigenbaum()
}</langsyntaxhighlight>
 
{{out}}
Line 288 ⟶ 972:
13 4.66920537
</pre>
 
 
=={{header|Groovy}}==
{{trans|Java}}
<syntaxhighlight lang="groovy">class Feigenbaum {
static void main(String[] args) {
int max_it = 13
int max_it_j = 10
double a1 = 1.0
double a2 = 0.0
double d1 = 3.2
double a
 
println(" i d")
for (int i = 2; i <= max_it; i++) {
a = a1 + (a1 - a2) / d1
for (int j = 0; j < max_it_j; j++) {
double x = 0.0
double y = 0.0
for (int k = 0; k < 1 << i; k++) {
y = 1.0 - 2.0 * y * x
x = a - x * x
}
a -= x / y
}
double d = (a1 - a2) / (a - a1)
printf("%2d %.8f\n", i, d)
d1 = d
a2 = a1
a1 = a
}
}
}</syntaxhighlight>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (mapAccumL)
 
feigenbaumApprox :: Int -> [Double]
Line 324 ⟶ 1,055:
(show <$> feigenbaumApprox 13)
where
justifyRight n c s = drop (length s) (replicate n c ++ s)</langsyntaxhighlight>
{{Out}}
<pre> 1 3.2185114220380866
Line 339 ⟶ 1,070:
12 4.669205372040318
13 4.669207514010413</pre>
 
=={{header|J}}==
Translated from the beautiful Fōrmulæ version. Rather than a verb, the conjunction pre-assigns m and n .
<pre>
Feigenbaum =: conjunction define NB. use: n Feigenbaum m
irange=: <. + i.@:>:@:|@:- NB. inclusive range
a=. 0 1
delta=. , 3.2
for_i. 3 irange n do.
tmp=. ({: + ({:delta) *inv ({: - _2&{)) a
for. i. m do.
'b bp'=. 0
for. i. 2 ^ <: i do.
'b bp'=. (tmp - *: b) , 1 _2 p. b * bp
end.
tmp=. tmp - b % bp
end.
a=. a , tmp
delta=. delta , %/@:(-/"1) (- 2 3 ,: 1 2) { a
end.
2 14j6 14j6 ": (#\ i. # delta) ,. (}. a) ,. delta
)
 
8 Feigenbaum 13
1 1.000000 3.200000
2 1.310703 3.218511
3 1.381547 4.385678
4 1.396945 4.600949
5 1.400253 4.655130
6 1.400962 4.666112
7 1.401114 4.668549
8 1.401146 4.669061
9 1.401153 4.669172
10 1.401155 4.669195
11 1.401155 4.669200
12 1.401155 4.669201
</pre>
 
=={{header|Java}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="java">public class Feigenbaum {
public static void main(String[] args) {
int max_it = 13;
Line 370 ⟶ 1,138:
}
}
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 385 ⟶ 1,153:
12 4.66920098
13 4.66920537</pre>
 
=={{header|jq}}==
<syntaxhighlight lang="jq">def feigenbaum_delta(imax; jmax):
def lpad: tostring | (" " * (4 - length)) + .;
def pp(i;x): "\(i|lpad) \(x)";
 
"Feigenbaum's delta constant incremental calculation:",
pp("i"; "δ"),
pp(1; "3.20"),
( foreach range(2; 1+imax) as $i (
{a1: 1.0, a2: 0.0, d1: 3.2};
 
.a = .a1 + (.a1 - .a2) / .d1
| reduce range(1; 1+jmax) as $j (.;
.x = 0 | .y = 0
| reduce range(1; 1+pow(2;$i)) as $k (.;
.y = (1 - 2 * .x * .y)
| .x = .a - (.x * .x) )
| .a -= (.x / .y) )
| .d = (.a1 - .a2) / (.a - .a1)
| .d1 = .d | .a2 = .a1 | .a1 = .a;
pp($i; .d) ) ) ;
Feigenbaum_delta(13; 10)
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="sh">
Feigenbaum's delta constant incremental calculation:
i δ
1 3.20
2 3.2185114220380866
3 4.3856775985683365
4 4.600949276538056
5 4.6551304953919646
6 4.666111947822846
7 4.668548581451485
8 4.66906066077106
9 4.669171554514976
10 4.669195154039278
11 4.669200256503637
12 4.669200975097843
13 4.669205372040318
</syntaxhighlight>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia"># http://en.wikipedia.org/wiki/Feigenbaum_constant
 
function feigenbaum_delta(imax=23, jmax=20)
a1, a2, d1 = BigFloat(1.0), BigFloat(0.0), BigFloat(3.2)
println("Feigenbaum's delta constant incremental calculation:\ni δ\n1 3.20")
for i in 2:imax
a = a1 + (a1 - a2) / d1
for j in 1:jmax
x, y = 0, 0
for k in 1:2^i
y = 1 - 2 * x * y
x = a - x * x
end
a -= x / y
end
d = (a1 - a2) / (a - a1)
println(rpad(i, 4), lpad(d, 4))
d1, a2 = d, a1
a1 = a
end
end
 
feigenbaum_delta()
</syntaxhighlight>{{out}}
<pre>
Feigenbaum's delta constant incremental calculation:
i δ
1 3.20
2 3.218511422038087912270504530742813256028820377971082199141994437483271226037533
3 4.385677598568339085744948568775522346103216356576497808699630752612705940390646
4 4.600949276538075357811694698623834985023552496633543372295593454454329771521727
5 4.655130495391980136486254995856898819475460497385226078363311588165123307017281
6 4.66611194782857138833121369671177648071905897173694216397236891198998639455025
7 4.668548581446840948044543680148146265543287896654348757317309551400403337843036
8 4.66906066064826823913259982263027263779968209542149740052288679867743088942764
9 4.669171555379511388886004609897567088240676573170789783804375113804695091803033
10 4.669195156030017174021108801191492093392147908605756405516325961597435372704323
11 4.669200229086856497938353781004067217408888048906823830162962242800074595934665
12 4.669201313294204171164754941185571183728248888986548913352217226469150028661929
13 4.669201545780906707506058109930429736431564330452605295006142805341042630340361
14 4.669201595537493910292470639289646040074547412490596040512777985387237785978782
15 4.669201606198152157723831097078594524421336516011873717994000712976201143278191
16 4.669201608480804423294067945898622842792868381815074127672747764898152898198069
17 4.669201608969744700482485321938373343907385540992447405883605282416375303280911
18 4.669201609074452566227981520370886753946099646679618270214759101315481224820708
19 4.669201609096878794705135037864783677622666525741836726064298799595215295927305
20 4.66920160910168168118696016084580172992808889324407617097679098039831535247408
21 4.669201609102710327837210208629111857781724142614997392167298168695631199065625
22 4.669201609102930630539778141205517641783439121041016813735799961205502985593042
23 4.66920160910297781286849594159066394676896043144121209732784416240857379387701
</pre>
 
=={{header|Kotlin}}==
{{trans|Ring}}
<langsyntaxhighlight lang="scala">// Version 1.2.40
 
fun feigenbaum() {
Line 418 ⟶ 1,282:
fun main(args: Array<String>) {
feigenbaum()
}</langsyntaxhighlight>
 
{{output}}
Line 436 ⟶ 1,300:
13 4.66920537
</pre>
 
=={{header|Lambdatalk}}==
Following the Python code in a recursive mode.
<syntaxhighlight lang="scheme">
{feigenbaum 11} // on my computer stackoverflow for values greater than 11
-> [3.2185114220380866,4.3856775985683365,4.600949276538056,4.6551304953919646,4.666111947822846,
4.668548581451485,4.66906066077106,4.669171554514976,4.669195154039278,4.669200256503637]
 
with:
 
{def feigenbaum
{lambda {:maxi}
{f3 :maxi 10 1 0 3.2 0 {A.new} 2}}}
 
{def f3
{lambda {:maxi :maxj :a1 :a2 :d1 :a3 :s :i}
{if {< :i {+ :maxi 1}}
then {let { {:maxi :maxi} {:maxj :maxj} {:a1 :a1} {:a2 :a2}
{:a3 {f2 {+ :a1 {/ {- :a1 :a2} :d1}} :i :maxj 1} }
{:s :s} {:i :i}
} {f3 :maxi :maxj :a3 :a1 {/ {- :a1 :a2} {- :a3 :a1}} :a3
{A.addlast! {/ {- :a1 :a2} {- :a3 :a1}} :s} {+ :i 1}} }
else :s}}}
 
{def f2
{lambda {:a :i :maxj :j}
{if {< :j {+ :maxj 1}}
then {f2 {f1 :a :i 0 0 1} :i :maxj {+ :j 1}}
else :a}}}
 
{def f1
{lambda {:a :i :y :x :k}
{if {< :k {+ {pow 2 :i} 1}}
then {f1 :a :i {- 1 {* 2 :y :x}} {- :a {* :x :x}} {+ :k 1}}
else {- :a {/ :x :y}} }}}
 
</syntaxhighlight>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">function leftShift(n,p)
local r = n
while p>0 do
r = r * 2
p = p - 1
end
return r
end
 
-- main
 
local MAX_IT = 13
local MAX_IT_J = 10
local a1 = 1.0
local a2 = 0.0
local d1 = 3.2
 
print(" i d")
for i=2,MAX_IT do
local a = a1 + (a1 - a2) / d1
for j=1,MAX_IT_J do
local x = 0.0
local y = 0.0
for k=1,leftShift(1,i) do
y = 1.0 - 2.0 * y * x
x = a - x * x
end
a = a - x / y
end
d = (a1 - a2) / (a - a1)
print(string.format("%2d %.8f", i, d))
d1 = d
a2 = a1
a1 = a
end</syntaxhighlight>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|M2000 Interpreter}}==
Using decimal type (26 decimal places) is better for this calculation (this has the same output as FORTRAN). Variable maxitj can be change to lower values when the i get higher value. Although we can't go lower than 2. So here we can start with 13, and lower to 2 for 16th iteration of i
 
<syntaxhighlight lang="m2000 interpreter">
module Feigenbaum_constant_calculation (maxit as integer, c as single){
locale 1033 // show dot for decimal separator symbol
single maxitj=13
integer i, j
long k
decimal a1=1, a2, d , d1=3.2, y, x, a
print "Feigenbaum constant calculation:"
print
print format$("{0:-7} {1:-12} {2}","i", "δ","max j")
for i = 2 to maxit
a=a1+(a1-a2)/d1
for j = 1 to maxitj {x=0:y=0:for k=1 to 2&^i {y=1@-2@*y*x:x=a-x*x}:a-=x/y}
d=(a1-a2)/(a-a1)
print format$("{0::-7} {1:10:-12} {2::-5}",i, d, j-1)
maxitj-=c
d1=d:a2=a1:a1= a
next
}
profiler
Feigenbaum_constant_calculation 18, .7
print timecount
</syntaxhighlight>
{{out}}
<pre>
i δ max j
2 3.2185114220 13
3 4.3856775986 12
4 4.6009492765 12
5 4.6551304954 11
6 4.6661119478 10
7 4.6685485814 10
8 4.6690606606 9
9 4.6691715554 8
10 4.6691951560 7
11 4.6692002291 7
12 4.6692013133 6
13 4.6692015458 5
14 4.6692015955 5
15 4.6692016062 4
16 4.6692016085 3
17 4.6692016090 3
18 4.6692016091 2
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
{{trans|D}}
<syntaxhighlight lang="mathematica">maxit = 13;
maxitj = 10;
a1 = 1.0;
a2 = 0.0;
d1 = 3.2;
a = 0.0;
Table[
a = a1 + (a1 - a2)/d1;
Do[
x = 0.0;
y = 0.0;
Do[
y = 1.0 - 2.0 y x;
x = a - x x;
,
{k, 1, 2^i}
];
a = a - x/y
,
{j, maxitj}
];
d = (a1 - a2)/(a - a1);
d1 = d;
a2 = a1;
a1 = a;
{i, d}
,
{i, 2, maxit}
] // Grid</syntaxhighlight>
{{out}}
<pre>2 3.21851
3 4.38568
4 4.60095
5 4.65513
6 4.66611
7 4.66855
8 4.66906
9 4.66917
10 4.6692
11 4.6692
12 4.6692
13 4.66921</pre>
 
=={{header|Modula-2}}==
<langsyntaxhighlight lang="modula2">MODULE Feigenbaum;
FROM FormatString IMPORT FormatString;
FROM LongStr IMPORT RealToStr;
Line 480 ⟶ 1,525:
 
ReadChar
END Feigenbaum.</langsyntaxhighlight>
 
=={{header|Nim}}==
{{trans|Kotlin}}
<syntaxhighlight lang="nim">import strformat
 
iterator feigenbaum(): tuple[n: int; δ: float] =
## Yield successive approximations of Feigenbaum constant.
 
const
MaxI = 13
MaxJ = 10
var
a1 = 1.0
a2 = 0.0
δ = 3.2
 
for i in 2..MaxI:
var a = a1 + (a1 - a2) / δ
for j in 1..MaxJ:
var x, y = 0.0
for _ in 1..(1 shl i):
y = 1 - 2 * y * x
x = a - x * x
a -= x / y
 
δ = (a1 - a2) / (a - a1)
a2 = a1
a1 = a
yield (i, δ)
 
echo " i δ"
for n, δ in feigenbaum():
echo fmt"{n:2d} {δ:.8f}"</syntaxhighlight>
 
{{out}}
<pre> i δ
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|Perl}}==
<syntaxhighlight lang ="perl">$a1 =use 1.0strict;
use warnings;
$a2 = 0.0;
use Math::AnyNum 'sqr';
$d1 = 3.2;
 
my $a1 = 1.0;
my $a2 = 0.0;
my $d1 = 3.2;
 
print " i δ\n";
Line 496 ⟶ 1,593:
for (1 .. 2**$i) {
$y = 1 - 2 * $y * $x;
$x = $a - sqr($x*$x);
}
$a -= $x/$y;
Line 504 ⟶ 1,601:
($a2, $a1) = ($a1, $a);
printf "%2d %17.14f\n", $i, $d1;
}</langsyntaxhighlight>
{{out}}
<pre> 2 3.21851142203809
3 4.38567759856834
4 4.6009492765380660094927653808
5 4.6551304953919665513049539198
6 4.6661119478228566611194782857
7 4.6685485814514866854858144684
8 4.6690606607710666906066064827
9 4.6691715545149866917155537951
10 4.6691951540392866919515603002
11 4.6692002565036466920022908686
12 4.6692009750978466920131329420
13 4.6692053720403266920154578091</pre>
 
=={{header|Perl 6}}==
{{works with|Rakudo|2018.04.01}}
{{trans|Ring}}
 
<lang perl6>my $a1 = 1;
my $a2 = 0;
my $d = 3.2;
 
say ' i d';
 
for 2 .. 13 -> $exp {
my $a = $a1 + ($a1 - $a2) / $d;
do {
my $x = 0;
my $y = 0;
for ^2 ** $exp {
$y = 1 - 2 * $y * $x;
$x = $a - $x²;
}
$a -= $x / $y;
} xx 10;
$d = ($a1 - $a2) / ($a - $a1);
($a2, $a1) = ($a1, $a);
printf "%2d %.8f\n", $exp, $d;
}</lang>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|Phix}}==
{{trans|Ring}}
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>constant maxIt = 13,
<span style="color: #008080;">constant</span> <span style="color: #000000;">maxIt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">13</span><span style="color: #0000FF;">,</span>
maxItJ = 10
<span style="color: #000000;">maxItJ</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span>
atom a1 = 1.0,
<span style="color: #004080;">atom</span> <span style="color: #000000;">a1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1.0</span><span style="color: #0000FF;">,</span>
a2 = 0.0,
<span style="color: #000000;">a2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0.0</span><span style="color: #0000FF;">,</span>
d1 = 3.2
<span style="color: #000000;">d1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3.2</span>
puts(1," i d\n")
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" i d\n"</span><span style="color: #0000FF;">)</span>
for i=2 to maxIt do
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">maxIt</span> <span style="color: #008080;">do</span>
atom a = a1 + (a1 - a2) / d1
<span style="color: #004080;">atom</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a1</span> <span style="color: #0000FF;">+</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">a1</span> <span style="color: #0000FF;">-</span> <span style="color: #000000;">a2</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">/</span> <span style="color: #000000;">d1</span>
for j=1 to maxItJ do
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">maxItJ</span> <span style="color: #008080;">do</span>
atom x = 0, y = 0
<span style="color: #004080;">atom</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
for k=1 to power(2,i) do
<span style="color: #008080;">for</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
y = 1 - 2*y*x
<span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span> <span style="color: #0000FF;">-</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">y</span><span style="color: #0000FF;">*</span><span style="color: #000000;">x</span>
x = a - x*x
<span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">-</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">*</span><span style="color: #000000;">x</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
a = a - x/y
<span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">-</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">/</span><span style="color: #000000;">y</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
atom d = (a1-a2)/(a-a1)
<span style="color: #004080;">atom</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">a1</span><span style="color: #0000FF;">-</span><span style="color: #000000;">a2</span><span style="color: #0000FF;">)/(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">-</span><span style="color: #000000;">a1</span><span style="color: #0000FF;">)</span>
printf(1,"%2d %.8f\n",{i,d})
<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;">"%2d %.8f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">d</span><span style="color: #0000FF;">})</span>
d1 = d
<span style="color: #000000;">d1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">d</span>
a2 = a1
<span style="color: #000000;">a2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a1</span>
a1 = a
<span style="color: #000000;">a1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a</span>
end for</lang>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 602 ⟶ 1,661:
=={{header|Python}}==
{{trans|D}}
<langsyntaxhighlight lang="python">max_it = 13
max_it_j = 10
a1 = 1.0
Line 623 ⟶ 1,682:
d1 = d
a2 = a1
a1 = a</langsyntaxhighlight>
{{out}}
<pre> i d
Line 641 ⟶ 1,700:
=={{header|Racket}}==
{{trans|C}}
<langsyntaxhighlight lang="racket">#lang racket
(define (feigenbaum #:max-it (max-it 13) #:max-it-j (max-it-j 10))
(displayln " i d" (current-error-port))
Line 660 ⟶ 1,719:
 
(module+ main
(feigenbaum))</langsyntaxhighlight>
{{out}}
<pre> i d
Line 676 ⟶ 1,735:
13 4.66920537
4.669205372040318</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2018.04.01}}
{{trans|Ring}}
 
<syntaxhighlight lang="raku" line>my $a1 = 1;
my $a2 = 0;
my $d = 3.2;
 
say ' i d';
 
for 2 .. 13 -> $exp {
my $a = $a1 + ($a1 - $a2) / $d;
do {
my $x = 0;
my $y = 0;
for ^2 ** $exp {
$y = 1 - 2 * $y * $x;
$x = $a - $x²;
}
$a -= $x / $y;
} xx 10;
$d = ($a1 - $a2) / ($a - $a1);
($a2, $a1) = ($a1, $a);
printf "%2d %.8f\n", $exp, $d;
}</syntaxhighlight>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|REXX}}==
{{trans|Sidef}}
=== Version 1 ===
<lang rexx>/*REXX pgm calculates the (Mitchell) Feigenbaum bifurcation velocity, #digs can be given*/
<syntaxhighlight lang="rexx">/*REXX pgm calculates the (Mitchell) Feigenbaum bifurcation velocity, #digs can be given*/
parse arg digs maxi maxj . /*obtain optional argument from the CL.*/
if digs=='' | digs=="," then digs= 30 /*Not specified? Then use the default.*/
Line 685 ⟶ 1,786:
if maxJ=='' | maxJ=="," then maxJ= 10 /* " " " " " " */
#= 4.669201609102990671853203820466201617258185577475768632745651343004134330211314737138,
|| 68974402394801381716 || 68974402394801381716 /*◄──Feigenbaum's constant, true value.*/
numeric digits digs /*use the specified # of decimal digits*/
a1= 1
Line 692 ⟶ 1,793:
say 'Using ' maxJ " iterations for maxJ, with " digs ' decimal digits:'
say
say copies(' ', 9) center('"correct'", 11) copies(' ', digs+1)
say center('i', 9, "─") center('digits' , 11, '"─'") center('d', digs+1, "─")
 
do i=2 for maxi-1
Line 709 ⟶ 1,810:
parse value d a1 a with d1 a2 a1 /*assign 3 variables with 3 new values.*/
end /*i*/
say /*stick a fork in it, we're all done. */
say left('', 9 + 1 + 11 + 1 + truet value= ' # / 1)"↑" /*trueshow valueposition of Feigenbaum'sgreatest constantaccuracy. */</lang>
say ' true value= ' # / 1 /*true value of Feigenbaum's constant. */</syntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 736 ⟶ 1,838:
19 10 4.66920160909687888294310165196
20 12 4.66920160910169069039564432665
↑
 
true value= 4.66920160910299067185320382047
</pre>
=== Version 2 ===
It was observed that variable a already becomes stable in less than 10 iterations. In below program, version 1 is repeated in a more readable form (Original) and maxj was discarded in favor of the dynamic test on a changed variable a (Optimized).
<syntaxhighlight lang="rexx">
arg n; if n = '' then n = 30; numeric digits n
parse version version; say version; glob. = ''
say 'First Fiegenbaum constant, correct to about 11 decimals'
say 'Using algorithm cf RosettaCode'
say
call time('r'); a = Original(); e = format(time('e'),,3)
say 'Original ' a '('e 'seconds)'
call time('r'); a = Optimized(); e = format(time('e'),,3)
say 'Optimized ' a '('e 'seconds)'
call time('r'); a = TrueValue(); e = format(time('e'),,3)
say 'True value' a '('e 'seconds)'
exit
 
Original:
procedure expose glob.
/* Outer 2 loops with a fixed value */
numeric digits digits()+2
im = 20; jm = 10
a1 = 1; a2 = 0; d1 = 3.2
do i = 2 to im
a = a1 + (a1-a2)/d1
do j = 1 to jm
x = 0; y = 0
do k = 1 to 2**i
y = 1 - 2*x*y; x = a - x*x
end
a = a - x/y
end
d = (a1-a2) / (a-a1)
parse value d a1 a with d1 a2 a1
end
numeric digits digits()-2
return d+0
 
Optimized:
procedure expose glob.
/* Center loop stops on achieving desired accuracy */
numeric digits digits()+4; numeric fuzz 4
/* Only outer loop maximum */
im = 20
a1 = 1; a2 = 0; d1 = 3.2
do i = 2 to im
a = a1 + (a1-a2)/d1; v = 0
do forever
x = 0; y = 0
do 2**i
y = 1 - 2*x*y; x = a - x*x
end
a = a - x/y
/* Stop second loop when a does not change anymore */
if a = v then
leave
v = a
end
d = (a1-a2) / (a-a1)
parse value d a1 a with d1 a2 a1
end
numeric digits digits()-4
return d+0
 
TrueValue:
procedure expose glob.
return 4.66920160910299067185320382046620161725818557747576863274565134300413433021131473713868974402394801381716+0
</syntaxhighlight>
{{out|output}}
Still using 30 digits and 10 for the outer loop, this yields:
<pre>
REXX-ooRexx_5.0.0(MT)_64-bit 6.05 23 Dec 2022
First Fiegenbaum constant, correct to about 11 decimals
Using algorithm cf RosettaCode
 
Original 4.66920160910168221375050076911 (97.186 seconds)
Optimized 4.66920160910168170137172844325 (21.927 seconds)
True value 4.66920160910299067185320382047 (0.000 seconds)
 
Intermediate results:
2 3.218511422038
3 4.385677598568
4 4.600949276538
5 4.655130495392
6 4.666111947829
7 4.668548581447
8 4.669060660648
9 4.669171555380
10 4.669195156030
11 4.669200229087
12 4.669201313294
13 4.669201545781
14 4.669201595537
15 4.669201606198
16 4.669201608481
17 4.669201608970
18 4.669201609074
19 4.669201609097
20 4.669201609102
</pre>
 
Apparently you needed 20 iterations to gain 10-11 correct decimals.
 
=={{header|Ring}}==
<syntaxhighlight lang="ring"># Project : Feigenbaum constant calculation
<lang ring>
# Project : Feigenbaum constant calculation
 
decimals(8)
Line 772 ⟶ 1,974:
a2 = a1
a1 = a
next</syntaxhighlight>
next
</lang>
Output:
<pre>Feigenbaum constant calculation:
<pre>
Feigenbaum constant calculation:
i d
2 3.21851142
Line 789 ⟶ 1,989:
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|RPL}}==
{{trans|Python}}
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Python code
|-
|
≪ { }
13 10 → maxit maxitj
≪ 3.2 1 0
2 maxit 1 + '''FOR''' ii
DUP2 - 4 PICK / 3 PICK +
1 maxitj 1 + '''START'''
0 0
1 2 ii ^ '''START'''
OVER * 2 * 1 SWAP -
3 PICK ROT SQ - SWAP '''NEXT'''
/ - '''NEXT'''
3 PICK ROT - OVER 4 PICK - /
5 ROLL OVER + 5 ROLLD
4 ROLL DROP SWAP ROT '''NEXT'''
3 DROPN
≫ ≫
´'''FBAUM'''’ STO
|
'''FBAUM''' ''( -- { δ1..δ13 } )''
max_it, max_it_j = 13, 10
d1, a1, a2 = 3.2, 1, 0
for i in range(2, max_it + 1):
a = a1 + (a1 - a2) / d1
for j in range(1, max_it_j + 1):
x = y = 0
for k in range(1, (1 << i) + 1):
y = 1.0 - 2.0 * y * x
x = a - x * x
a = a - x / y
d = (a1 - a2) / (a - a1)
print(d)
d1, a2, a1 = d, a1, a
clean stack
.
.
|}
{{out}}
<pre>
1: { 3.21851142204 4.38567759857 4.60094927654 4.65513049539 4.66611194782 4.66854858152 4.66906066029 4.66917155686 4.6691951528 4.66920033694 4.66920090912 4.66920429563 4.66917851362 }
</pre>
The above program (limited at 10 iterations) takes 33 minutes and 50 seconds to be executed on a HP-28S.
 
=={{header|Ruby}}==
{{trans|C#}}
<syntaxhighlight lang="ruby">def main
maxIt = 13
maxItJ = 10
a1 = 1.0
a2 = 0.0
d1 = 3.2
puts " i d"
for i in 2 .. maxIt
a = a1 + (a1 - a2) / d1
for j in 1 .. maxItJ
x = 0.0
y = 0.0
for k in 1 .. 1 << i
y = 1.0 - 2.0 * y * x
x = a - x * x
end
a = a - x / y
end
d = (a1 - a2) / (a - a1)
print "%2d %.8f\n" % [i, d]
d1 = d
a2 = a1
a1 = a
end
end
 
main()</syntaxhighlight>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|Scala}}==
===Imperative, ugly===
<syntaxhighlight lang="scala">object Feigenbaum1 extends App {
val (max_it, max_it_j) = (13, 10)
var (a1, a2, d1, a) = (1.0, 0.0, 3.2, 0.0)
 
println(" i d")
var i: Int = 2
while (i <= max_it) {
a = a1 + (a1 - a2) / d1
for (_ <- 0 until max_it_j) {
var (x, y) = (0.0, 0.0)
for (_ <- 0 until 1 << i) {
y = 1.0 - 2.0 * y * x
x = a - x * x
}
a -= x / y
}
val d: Double = (a1 - a2) / (a - a1)
printf("%2d %.8f\n", i, d)
d1 = d
a2 = a1
a1 = a
i += 1
}
 
}</syntaxhighlight>
===Functional Style, Tail recursive===
{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/OjA3sae/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/04eS3BfCShmrA7I8ZmQfJA Scastie (remote JVM)].
<syntaxhighlight lang="scala">object Feigenbaum2 extends App {
private val (max_it, max_it_j) = (13, 10)
 
private def result = {
 
@scala.annotation.tailrec
def outer(i: Int, d1: Double, a2: Double, a1: Double, acc: Seq[Double]): Seq[Double] = {
@scala.annotation.tailrec
def center(j: Int, a: Double): Double = {
@scala.annotation.tailrec
def inner(k: Int, end: Int, x: Double, y: Double): (Double, Double) =
if (k < end) inner(k + 1, end, a - x * x, 1.0 - 2.0 * y * x) else (x, y)
 
val (x, y) = inner(0, 1 << i, 0.0, 0.0)
if (j < max_it_j) {
center(j + 1, a - (x / y))
} else a
}
 
if (i <= max_it) {
val a = center(0, a1 + (a1 - a2) / d1)
val d: Double = (a1 - a2) / (a - a1)
 
outer(i + 1, d, a1, a, acc :+ d)
} else acc
}
 
outer(2, 3.2, 0, 1.0, Seq[Double]()).zipWithIndex
}
 
println(" i ≈ δ")
result.foreach { case (δ, i) => println(f"${i + 2}%2d $δ%.8f") }
 
}</syntaxhighlight>
 
=={{header|Sidef}}==
{{trans|Perl 6Raku}}
<langsyntaxhighlight lang="ruby">var a1 = 1
var a2 = 0
var δ = 3.2.float
Line 813 ⟶ 2,170:
(a2, a1) = (a1, a0)
printf("%2d %.8f\n", i, δ)
}</langsyntaxhighlight>
{{out}}
<pre>
Line 831 ⟶ 2,188:
14 4.66920160
15 4.66920161
</pre>
 
=={{header|Swift}}==
 
{{trans|C}}
 
<syntaxhighlight lang="swift">import Foundation
 
func feigenbaum(iterations: Int = 13) {
var a = 0.0
var a1 = 1.0
var a2 = 0.0
var d = 0.0
var d1 = 3.2
 
print(" i d")
 
for i in 2...iterations {
a = a1 + (a1 - a2) / d1
 
for _ in 1...10 {
var x = 0.0
var y = 0.0
 
for _ in 1...1<<i {
y = 1.0 - 2.0 * y * x
x = a - x * x
}
 
a -= x / y
}
 
d = (a1 - a2) / (a - a1)
d1 = d
(a1, a2) = (a, a1)
 
print(String(format: "%2d %.8f", i, d))
}
}
 
feigenbaum()</syntaxhighlight>
 
{{out}}
 
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Module Module1
 
Sub Main()
Dim maxIt = 13
Dim maxItJ = 10
Dim a1 = 1.0
Dim a2 = 0.0
Dim d1 = 3.2
Console.WriteLine(" i d")
For i = 2 To maxIt
Dim a = a1 + (a1 - a2) / d1
For j = 1 To maxItJ
Dim x = 0.0
Dim y = 0.0
For k = 1 To 1 << i
y = 1.0 - 2.0 * y * x
x = a - x * x
Next
a -= x / y
Next
Dim d = (a1 - a2) / (a - a1)
Console.WriteLine("{0,2:d} {1:f8}", i, d)
d1 = d
a2 = a1
a1 = a
Next
End Sub
 
End Module</syntaxhighlight>
{{out}}
<pre> i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537</pre>
 
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">fn feigenbaum() {
max_it, max_itj := 13, 10
mut a1, mut a2, mut d1 := 1.0, 0.0, 3.2
println(" i d")
for i := 2; i <= max_it; i++ {
mut a := a1 + (a1-a2)/d1
for j := 1; j <= max_itj; j++ {
mut x, mut y := 0.0, 0.0
for k := 1; k <= 1<<u32(i); k++ {
y = 1.0 - 2.0*y*x
x = a - x*x
}
a -= x / y
}
d := (a1 - a2) / (a - a1)
println("${i:2} ${d:.8f}")
d1, a2, a1 = d, a1, a
}
}
fn main() {
feigenbaum()
}</syntaxhighlight>
 
{{out}}
<pre>
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|Wren}}==
{{trans|Ring}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
 
var feigenbaum = Fn.new {
var maxIt = 13
var maxItJ = 10
var a1 = 1
var a2 = 0
var d1 = 3.2
System.print(" i d")
for (i in 2..maxIt) {
var a = a1 + (a1 - a2)/d1
for (j in 1..maxItJ) {
var x = 0
var y = 0
for (k in 1..(1<<i)) {
y = 1 - 2*y*x
x = a - x*x
}
a = a - x/y
}
var d = (a1 - a2)/(a - a1)
System.print("%(Fmt.d(2, i)) %(Fmt.f(0, d, 8))")
d1 = d
a2 = a1
a1 = a
}
}
 
feigenbaum.call()</syntaxhighlight>
 
{{out}}
<pre>
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|XPL0}}==
{{trans|Wren}}
<syntaxhighlight lang "XPL0">def MaxIt = 13, MaxItJ = 10;
real A, A1, A2, D, D1, X, Y;
int I, J, K;
[A1:= 1.; A2:= 0.; D1:= 3.2;
Text(0, " i d^m^j");
for I:= 2 to MaxIt do
[A:= A1 + (A1-A2)/D1;
for J:= 1 to MaxItJ do
[X:= 0.; Y:= 0.;
for K:= 1 to 1<<I do
[Y:= 1. - 2.*Y*X;
X:= A - X*X;
];
A:= A - X/Y;
];
D:= (A1-A2) / (A-A1);
Format(2, 0); RlOut(0, float(I));
Format(5, 8); RlOut(0, D);
CrLf(0);
D1:= D;
A2:= A1;
A1:= A;
];
]</syntaxhighlight>
{{out}}
<pre>
i d
2 3.21851142
3 4.38567760
4 4.60094928
5 4.65513050
6 4.66611195
7 4.66854858
8 4.66906066
9 4.66917155
10 4.66919515
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
 
=={{header|zkl}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="zkl">fcn feigenbaum{
maxIt,maxItJ,a1,a2,d1,a,d := 13, 10, 1.0, 0.0, 3.2, 0, 0;
println(" i d");
Line 849 ⟶ 2,444:
d1,a2,a1 = d,a1,a;
}
}();</langsyntaxhighlight>
{{out}}
<pre>
Retrieved from "https://rosettacode.org/wiki/Feigenbaum_constant_calculation"