Feigenbaum constant calculation: Difference between revisions
m
→{{header|EasyLang}}
Thundergnat (talk | contribs) m (→{{header|Ring}}: Remove vanity tags) |
|||
| (86 intermediate revisions by 32 users not shown) | |||
Line 1:
{{
;Task:
Calculate the Feigenbaum constant.
;See:
:* 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">
# syntax: GAWK -f FEIGENBAUM_CONSTANT_CALCULATION.AWK
BEGIN {
a1 = 1
a2 = 0
d1 = 3.2
max_i = 13
max_j = 10
print(" i d")
for (i=2; i<=max_i; i++) {
a = a1 + (a1 - a2) / d1
for (j=1; j<=max_j; j++) {
x = y = 0
for (k=1; k<=2^i; k++) {
y = 1 - 2 * y * x
x = a - x * x
}
a -= x / y
}
d = (a1 - a2) / (a - a1)
printf("%2d %.8f\n",i,d)
d1 = d
a2 = a1
a1 = a
}
exit(0)
}
</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|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}}
<
void feigenbaum() {
Line 38 ⟶ 425:
feigenbaum();
return 0;
}</
{{output}}
<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 sharp|C#}}==
{{trans|Kotlin}}
<syntaxhighlight lang="csharp">using System;
namespace FeigenbaumConstant {
class Program {
static void Main(string[] args) {
var maxIt = 13;
var maxItJ = 10;
var a1 = 1.0;
var a2 = 0.0;
var d1 = 3.2;
Console.WriteLine(" i d");
for (int i = 2; i <= maxIt; i++) {
var a = a1 + (a1 - a2) / d1;
for (int j = 1; j <= maxItJ; j++) {
var x = 0.0;
var 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;
}
var d = (a1 - a2) / (a - a1);
Console.WriteLine("{0,2:d} {1:f8}", 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|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
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|D}}==
<syntaxhighlight lang="d">import std.stdio;
void main() {
int max_it = 13;
int max_it_j = 10;
double a1 = 1.0;
double a2 = 0.0;
double d1 = 3.2;
double a;
writeln(" i d");
for (int i=2; i<=max_it; i++) {
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);
writefln("%2d %.8f", 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.66920028
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
Line 59 ⟶ 928:
=={{header|Go}}==
{{trans|Ring}}
<
import "fmt"
Line 85 ⟶ 954:
func main() {
feigenbaum()
}</
{{out}}
Line 102 ⟶ 971:
12 4.66920098
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}}==
<syntaxhighlight lang="haskell">import Data.List (mapAccumL)
feigenbaumApprox :: Int -> [Double]
feigenbaumApprox mx = snd $ mitch mx 10
where
mitch :: Int -> Int -> ((Double, Double, Double), [Double])
mitch mx mxj =
mapAccumL
(\(a1, a2, d1) i ->
let a =
iterate
(\a ->
let (x, y) =
iterate
(\(x, y) -> (a - (x * x), 1.0 - ((2.0 * x) * y)))
(0.0, 0.0) !!
(2 ^ i)
in a - (x / y))
(a1 + (a1 - a2) / d1) !!
mxj
d = (a1 - a2) / (a - a1)
in ((a, a1, d), d))
(1.0, 0.0, 3.2)
[2 .. (1 + mx)]
-- TEST ------------------------------------------------------------------
main :: IO ()
main =
(putStrLn . unlines) $
zipWith
(\i s -> justifyRight 2 ' ' (show i) ++ '\t' : s)
[1 ..]
(show <$> feigenbaumApprox 13)
where
justifyRight n c s = drop (length s) (replicate n c ++ s)</syntaxhighlight>
{{Out}}
<pre> 1 3.2185114220380866
2 4.3856775985683365
3 4.600949276538056
4 4.6551304953919646
5 4.666111947822846
6 4.668548581451485
7 4.66906066077106
8 4.669171554514976
9 4.669195154039278
10 4.669200256503637
11 4.669200975097843
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}}
<syntaxhighlight lang="java">public class Feigenbaum {
public 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;
System.out.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);
System.out.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|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}}
<
fun feigenbaum() {
Line 136 ⟶ 1,282:
fun main(args: Array<String>) {
feigenbaum()
}</
{{output}}
Line 154 ⟶ 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}}==
<
FROM FormatString IMPORT FormatString;
FROM LongStr IMPORT RealToStr;
Line 198 ⟶ 1,525:
ReadChar
END Feigenbaum.</
=={{header|
{{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
var
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">use strict;
use warnings;
use Math::AnyNum 'sqr';
my $a1 = 1.0;
my $a2 = 0.0;
my $d1 = 3.2;
print " i δ\n";
for my $i (2..13) {
my $a = $a1 + ($a1 - $a2)/$d1;
for (1..10) {
my $x = 0;
my $y = 0;
for
$y = 1 - 2 * $y * $x;
$x = $a - sqr($x
}
$a -= $x
}
$d1 = ($
($a2,
printf "%2d %17.14f\n", $i, $d1;
}</syntaxhighlight>
{{out}}
<pre>
3 4.38567759856834
4 4.60094927653808
5 4.65513049539198
6 4.66611194782857
7 4.66854858144684
8 4.66906066064827
9 4.66917155537951
10 4.66919515603002
11 4.66920022908686
12 4.66920131329420
13 4.66920154578091</pre>
=={{header|Phix}}==
{{trans|Ring}}
<!--<syntaxhighlight lang="phix">(phixonline)-->
<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>
<span style="color: #000000;">maxItJ</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span>
<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>
<span style="color: #000000;">a2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0.0</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">d1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3.2</span>
<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>
<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>
<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>
<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>
<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>
<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>
<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>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<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>
<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>
<span style="color: #000000;">d1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">d</span>
<span style="color: #000000;">a2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a1</span>
<span style="color: #000000;">a1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
i d
2 3.21851142
3 4.38567760
Line 238 ⟶ 1,656:
11 4.66920026
12 4.66920098
13 4.66920537
</pre>
=={{header|Python}}==
{{trans|D}}
<syntaxhighlight lang="python">max_it = 13
max_it_j = 10
a1 = 1.0
a2 = 0.0
d1 = 3.2
a = 0.0
print " i d"
for i in range(2, max_it + 1):
a = a1 + (a1 - a2) / d1
for j in range(1, max_it_j + 1):
x = 0.0
y = 0.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("{0:2d} {1:.8f}".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|Racket}}==
{{trans|C}}
<
(define (feigenbaum #:max-it (max-it 13) #:max-it-j (max-it-j 10))
(displayln " i d" (current-error-port))
Line 261 ⟶ 1,719:
(module+ main
(feigenbaum))</
{{out}}
<pre> i d
Line 277 ⟶ 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}}
<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.*/
if maxi=='' | maxi=="," then maxi= 20 /* " " " " " " */
if maxJ=='' | maxJ=="," then maxJ= 10 /* " " " " " " */
#= 4.669201609102990671853203820466201617258185577475768632745651343004134330211314737138,
|| 68974402394801381716 /*◄──Feigenbaum's constant, true value.*/
numeric digits digs /*use the specified # of decimal digits*/
a1= 1
a2= 0
d1= 3.2
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
a= a1 + (a1 - a2) / d1
do maxJ
x= 0; y= 0
do 2**i; y= 1 - 2 * x * y
x= a - x*x
end /*2**i*/
a= a - x / y
end /*maxj*/
d= (a1 - a2) / (a - a1) /*compute the delta (D) of the function*/
t= max(0, compare(d, #) - 2) /*# true digs so far, ignore dec. point*/
say center(i, 9) center(t, 11) d /*display values for I & D ──►terminal*/
parse value d a1 a with d1 a2 a1 /*assign 3 variables with 3 new values.*/
end /*i*/
/*stick a fork in it, we're all done. */
say left('', 9 + 1 + 11 + 1 + t )"↑" /*show position of greatest accuracy. */
say ' true value= ' # / 1 /*true value of Feigenbaum's constant. */</syntaxhighlight>
{{out|output|text= when using the default inputs:}}
<pre>
Using 10 iterations for maxJ, with 30 decimal digits:
correct
────i──── ──digits─── ───────────────d───────────────
2 0 3.21851142203808791227050453077
3 1 4.3856775985683390857449485682
4 2 4.60094927653807535781169469969
5 2 4.65513049539198013648625498649
6 3 4.66611194782857138833121364654
7 3 4.66854858144684094804454708811
8 4 4.66906066064826823913257549468
9 4 4.6691715553795113888859465442
10 4 4.66919515603001717402161720542
11 6 4.66920022908685649793393149233
12 7 4.66920131329420417113719511412
13 7 4.66920154578090670783369507315
14 7 4.66920159553749390966169074155
15 9 4.66920160619815215840788706632
16 9 4.66920160848080435144581223484
17 9 4.66920160896974538458267849027
18 10 4.66920160907444981238909862845
19 10 4.66920160909687888294310165196
20 12 4.66920160910169069039564432665
↑
true value= 4.66920160910299067185320382047
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring"># Project : Feigenbaum constant calculation
decimals(8)
Line 310 ⟶ 1,872:
a2 = a1
a1 = a
next</syntaxhighlight>
Output:
<pre>Feigenbaum constant calculation:
i d
2 3.21851142
Line 327 ⟶ 1,887:
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|
<
var a2 = 0
var δ = 3.2.float
Line 351 ⟶ 2,068:
(a2, a1) = (a1, a0)
printf("%2d %.8f\n", i, δ)
}</
{{out}}
<pre>
Line 369 ⟶ 2,086:
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}}
<
maxIt,maxItJ,a1,a2,d1,a,d := 13, 10, 1.0, 0.0, 3.2, 0, 0;
println(" i d");
Line 387 ⟶ 2,342:
d1,a2,a1 = d,a1,a;
}
}();</
{{out}}
<pre>
| |||