Feigenbaum constant calculation: Difference between revisions

{{trans|Python}}

 

V max_it_j = 10

V a1 = 1.0

d1 = d

a2 = a1

 

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

{{Trans|Ring}}

print( ( "Feigenbaum constant calculation:", newline ) );

a2 := a1;

a1 := a

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f FEIGENBAUM_CONSTANT_CALCULATION.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

13 4.66920537

</pre>

 

=={{header|C}}==

{{trans|Ring}}

 

void feigenbaum() {

feigenbaum();

return 0;

 

{{output}}

=={{header|C sharp|C#}}==

{{trans|Kotlin}}

 

namespace FeigenbaumConstant {

}

}

{{out}}

<pre> i d

=={{header|C++}}==

{{trans|C}}

 

int main() {

 

return 0;

{{out}}

<pre> i d

 

=={{header|D}}==

 

void main() {

a1 = a;

}

{{out}}

<pre> i d

12 4.66920099

13 4.66920555</pre>

 

=={{header|F#|F sharp}}==

{{trans|C#}}

 

[<EntryPoint>]

a2 <- a1

a1 <- a

{{out}}

<pre> i d

=={{header|Factor}}==

{{trans|Raku}}

 

[let

exp d "%2d %.8f\n" printf

] each

{{out}}

<pre>

 

=={{header|Fortran}}==

implicit none

 

print '(i4,f13.10)', i, d1

end do

{{out}}

<pre> i d

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Feigenbaum constant calculation:

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

{{trans|Ring}}

 

import "fmt"

func main() {

feigenbaum()

 

{{out}}

13 4.66920537

</pre>

 

=={{header|Haskell}}==

 

feigenbaumApprox :: Int -> [Double]

(show <$> feigenbaumApprox 13)

where

{{Out}}

<pre> 1 3.2185114220380866

=={{header|Java}}==

{{trans|Kotlin}}

public static void main(String[] args) {

int max_it = 13;

}

}

{{out}}

<pre> i d

12 4.66920098

13 4.66920537</pre>

 

=={{header|Julia}}==

 

function feigenbaum_delta(imax=23, jmax=20)

 

feigenbaum_delta()

<pre>

Feigenbaum's delta constant incremental calculation:

=={{header|Kotlin}}==

{{trans|Ring}}

 

fun feigenbaum() {

fun main(args: Array<String>) {

feigenbaum()

 

{{output}}

=={{header|Lambdatalk}}==

Following the Python code in a recursive mode.

{feigenbaum 11} // on my computer stackoverflow for values greater than 11

-> [3.2185114220380866,4.3856775985683365,4.600949276538056,4.6551304953919646,4.666111947822846,

else {- :a {/ :x :y}} }}}

 

 

=={{header|Lua}}==

local r = n

while p>0 do

a2 = a1

a1 = a

{{out}}

<pre> i d

12 4.66920098

13 4.66920537</pre>

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM LongStr IMPORT RealToStr;

 

ReadChar

 

=={{header|Nim}}==

{{trans|Kotlin}}

 

iterator feigenbaum(): tuple[n: int; δ: float] =

 

const

MaxI = 13

MaxJ = 10

var

a2 = 0.0

δ = 3.2

 

for i in 2..MaxI:

var a = a1 + (a1 - a2) / δ

for j in 1..MaxJ:

echo " i δ"

for n, δ in feigenbaum():

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use Math::AnyNum 'sqr';

($a2, $a1) = ($a1, $a);

printf "%2d %17.14f\n", $i, $d1;

{{out}}

<pre> 2 3.21851142203809

=={{header|Phix}}==

{{trans|Ring}}

{{out}}

<pre>

=={{header|Python}}==

{{trans|D}}

max_it_j = 10

a1 = 1.0

d1 = d

a2 = a1

{{out}}

<pre> i d

=={{header|Racket}}==

{{trans|C}}

(define (feigenbaum #:max-it (max-it 13) #:max-it-j (max-it-j 10))

(displayln " i d" (current-error-port))

 

(module+ main

{{out}}

<pre> i d

{{trans|Ring}}

 

my $a2 = 0;

my $d = 3.2;

($a2, $a1) = ($a1, $a);

printf "%2d %.8f\n", $exp, $d;

{{out}}

<pre> i d

=={{header|REXX}}==

{{trans|Sidef}}

parse arg digs maxi maxj . /*obtain optional argument from the CL.*/

if digs=='' | digs=="," then digs= 30 /*Not specified? Then use the default.*/

/*stick a fork in it, we're all done. */

say left('', 9 + 1 + 11 + 1 + t )"↑" /*show position of greatest accuracy. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

 

decimals(8)

a2 = a1

a1 = a

Output:

<pre>Feigenbaum constant calculation:

12 4.66920098

13 4.66920537</pre>

 

=={{header|Ruby}}==

{{trans|C#}}

maxIt = 13

maxItJ = 10

end

 

{{out}}

<pre> i d

=={{header|Scala}}==

===Imperative, ugly===

val (max_it, max_it_j) = (13, 10)

var (a1, a2, d1, a) = (1.0, 0.0, 3.2, 0.0)

}

 

===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)].

private val (max_it, max_it_j) = (13, 10)

 

result.foreach { case (δ, i) => println(f"${i + 2}%2d $δ%.8f") }

 

 

=={{header|Sidef}}==

{{trans|Raku}}

var a2 = 0

var δ = 3.2.float

(a2, a1) = (a1, a0)

printf("%2d %.8f\n", i, δ)

{{out}}

<pre>

{{trans|C}}

 

 

func feigenbaum(iterations: Int = 13) {

}

 

 

{{out}}

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

End Sub

 

{{out}}

<pre> i d

12 4.66920098

13 4.66920537</pre>

 

=={{header|Wren}}==

{{trans|Ring}}

{{libheader|Wren-fmt}}

 

var feigenbaum = Fn.new {

}

 

 

{{out}}

<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");

d1,a2,a1 = d,a1,a;

}

{{out}}

<pre>