Feigenbaum constant calculation: Difference between revisions

{{trans|Python}}

V max_it_j = 10

V a1 = 1.0

d1 = d

a2 = a1

{{out}}

=={{header|Ada}}==

{{Trans|Ring}}

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

feigenbaum;

end Main;

{{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>

=={{header|BASIC}}==

==={{header|BASIC256}}===

a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2

a2 = a1

a1 = a

{{out}}

<pre>Same as FreeBASIC entry.</pre>

==={{header|Just BASIC}}===

a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2

a2 = a1

a1 = a

==={{header|True BASIC}}===

LET maxitj = 13

LET a1 = 1.0

LET a1= a

NEXT i

{{out}}

<pre>Same as FreeBASIC entry.</pre>

==={{header|Yabasic}}===

a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2

a2 = a1

a1 = a

=={{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

=={{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|FutureBasic}}==

{{trans|Ring and Phix}}

window 1, @"Feignenbaum Constant", ( 0, 0, 200, 300 )

HandleEvents

{{output}}

<pre>

=={{header|Go}}==

{{trans|Ring}}

import "fmt"

func main() {

feigenbaum()

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

int max_it = 13

}

}

{{out}}

<pre> i d

=={{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

=={{header|jq}}==

def lpad: tostring | (" " * (4 - length)) + .;

def pp(i;x): "\(i|lpad) \(x)";

feigenbaum_delta(13; 10)

{{out}}

Feigenbaum's delta constant incremental calculation:

i δ

12 4.669200975097843

13 4.669205372040318

=={{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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{trans|D}}

maxitj = 10;

a1 = 1.0;

,

{i, 2, maxit}

{{out}}

<pre>2 3.21851

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

FROM FormatString IMPORT FormatString;

FROM LongStr IMPORT RealToStr;

ReadChar

=={{header|Nim}}==

{{trans|Kotlin}}

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

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}}

<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: #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>

{{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:

=={{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

=={{header|Vlang}}==

{{trans|Go}}

max_it, max_itj := 13, 10

mut a1, mut a2, mut d1 := 1.0, 0.0, 3.2

fn main() {

feigenbaum()

{{out}}

{{trans|Ring}}

{{libheader|Wren-fmt}}

var feigenbaum = Fn.new {

}

{{out}}

=={{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>