Jump to content

Feigenbaum constant calculation: Difference between revisions

Feigenbaum constant calculation (view source)

Revision as of 11:25, 27 August 2022

1,338 bytes added ,  1 year ago
m
syntax highlighting fixup automation
No edit summary
m (syntax highlighting fixup automation)
Line 12:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">V max_it = 13
V max_it_j = 10
V a1 = 1.0
Line 33:
d1 = d
a2 = a1
a1 = a</langsyntaxhighlight>
 
{{out}}
Line 54:
=={{header|Ada}}==
{{Trans|Ring}}
<syntaxhighlight lang="ada">
<lang Ada>
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
Line 101:
feigenbaum;
end Main;
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 122:
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
{{Trans|Ring}}
<langsyntaxhighlight lang="algol68"># Calculate the Feigenbaum constant #
print( ( "Feigenbaum constant calculation:", newline ) );
Line 151:
a2 := a1;
a1 := a
OD</langsyntaxhighlight>
{{out}}
<pre>
Line 171:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f FEIGENBAUM_CONSTANT_CALCULATION.AWK
BEGIN {
Line 198:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 218:
=={{header|BASIC}}==
==={{header|BASIC256}}===
<langsyntaxhighlight lang="freebasic">maxIt = 13 : maxItj = 13
a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2
 
Line 241:
a2 = a1
a1 = a
next i</langsyntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|Just BASIC}}===
<langsyntaxhighlight lang="lb">maxit = 13 : maxitj = 13
a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2
 
Line 269:
a2 = a1
a1 = a
next i</langsyntaxhighlight>
 
==={{header|True BASIC}}===
<langsyntaxhighlight lang="qbasic">LET maxit = 13
LET maxitj = 13
LET a1 = 1.0
Line 299:
LET a1= a
NEXT i
END</langsyntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|Yabasic}}===
<langsyntaxhighlight lang="freebasic">maxIt = 13 : maxItj = 13
a1 = 1.0 : a2 = 0.0 : d = 0.0 : d1 = 3.2
 
Line 326:
a2 = a1
a1 = a
next i</langsyntaxhighlight>
 
=={{header|C}}==
{{trans|Ring}}
<langsyntaxhighlight lang="c">#include <stdio.h>
 
void feigenbaum() {
Line 358:
feigenbaum();
return 0;
}</langsyntaxhighlight>
 
{{output}}
Line 379:
=={{header|C sharp|C#}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="csharp">using System;
 
namespace FeigenbaumConstant {
Line 409:
}
}
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 427:
=={{header|C++}}==
{{trans|C}}
<langsyntaxhighlight lang="cpp">#include <iostream>
 
int main() {
Line 454:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 471:
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio;
 
void main() {
Line 499:
a1 = a;
}
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 517:
=={{header|F#|F sharp}}==
{{trans|C#}}
<langsyntaxhighlight lang="fsharp">open System
 
[<EntryPoint>]
Line 541:
a2 <- a1
a1 <- a
0 // return an integer exit code</langsyntaxhighlight>
{{out}}
<pre> i d
Line 559:
=={{header|Factor}}==
{{trans|Raku}}
<langsyntaxhighlight lang="factor">USING: formatting io locals math math.ranges sequences ;
 
[let
Line 583:
exp d "%2d %.8f\n" printf
] each
]</langsyntaxhighlight>
{{out}}
<pre>
Line 602:
 
=={{header|Fortran}}==
<langsyntaxhighlight lang="fortran"> program feigenbaum
implicit none
 
Line 631:
print '(i4,f13.10)', i, d1
end do
end</langsyntaxhighlight>
{{out}}
<pre> i d
Line 655:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' version 25-0-2019
' compile with: fbc -s console
 
Line 687:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>Feigenbaum constant calculation:
Line 717:
=={{header|FutureBasic}}==
{{trans|Ring and Phix}}
<langsyntaxhighlight lang="futurebasic">
window 1, @"Feignenbaum Constant", ( 0, 0, 200, 300 )
 
Line 751:
 
HandleEvents
</syntaxhighlight>
</lang>
{{output}}
<pre>
Line 773:
=={{header|Go}}==
{{trans|Ring}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 799:
func main() {
feigenbaum()
}</langsyntaxhighlight>
 
{{out}}
Line 821:
=={{header|Groovy}}==
{{trans|Java}}
<langsyntaxhighlight lang="groovy">class Feigenbaum {
static void main(String[] args) {
int max_it = 13
Line 849:
}
}
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 866:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (mapAccumL)
 
feigenbaumApprox :: Int -> [Double]
Line 900:
(show <$> feigenbaumApprox 13)
where
justifyRight n c s = drop (length s) (replicate n c ++ s)</langsyntaxhighlight>
{{Out}}
<pre> 1 3.2185114220380866
Line 955:
=={{header|Java}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="java">public class Feigenbaum {
public static void main(String[] args) {
int max_it = 13;
Line 983:
}
}
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 1,000:
 
=={{header|jq}}==
<langsyntaxhighlight lang="jq">def feigenbaum_delta(imax; jmax):
def lpad: tostring | (" " * (4 - length)) + .;
def pp(i;x): "\(i|lpad) \(x)";
Line 1,024:
feigenbaum_delta(13; 10)
</syntaxhighlight>
</lang>
{{out}}
<syntaxhighlight lang="sh">
<lang sh>
Feigenbaum's delta constant incremental calculation:
i δ
Line 1,042:
12 4.669200975097843
13 4.669205372040318
</langsyntaxhighlight>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia"># http://en.wikipedia.org/wiki/Feigenbaum_constant
 
function feigenbaum_delta(imax=23, jmax=20)
Line 1,068:
 
feigenbaum_delta()
</langsyntaxhighlight>{{out}}
<pre>
Feigenbaum's delta constant incremental calculation:
Line 1,099:
=={{header|Kotlin}}==
{{trans|Ring}}
<langsyntaxhighlight lang="scala">// Version 1.2.40
 
fun feigenbaum() {
Line 1,129:
fun main(args: Array<String>) {
feigenbaum()
}</langsyntaxhighlight>
 
{{output}}
Line 1,150:
=={{header|Lambdatalk}}==
Following the Python code in a recursive mode.
<langsyntaxhighlight lang="scheme">
{feigenbaum 11} // on my computer stackoverflow for values greater than 11
-> [3.2185114220380866,4.3856775985683365,4.600949276538056,4.6551304953919646,4.666111947822846,
Line 1,183:
else {- :a {/ :x :y}} }}}
 
</syntaxhighlight>
</lang>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">function leftShift(n,p)
local r = n
while p>0 do
Line 1,220:
a2 = a1
a1 = a
end</langsyntaxhighlight>
{{out}}
<pre> i d
Line 1,238:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
{{trans|D}}
<langsyntaxhighlight Mathematicalang="mathematica">maxit = 13;
maxitj = 10;
a1 = 1.0;
Line 1,266:
,
{i, 2, maxit}
] // Grid</langsyntaxhighlight>
{{out}}
<pre>2 3.21851
Line 1,282:
 
=={{header|Modula-2}}==
<langsyntaxhighlight lang="modula2">MODULE Feigenbaum;
FROM FormatString IMPORT FormatString;
FROM LongStr IMPORT RealToStr;
Line 1,324:
 
ReadChar
END Feigenbaum.</langsyntaxhighlight>
 
=={{header|Nim}}==
{{trans|Kotlin}}
<langsyntaxhighlight Nimlang="nim">import strformat
 
iterator feigenbaum(): tuple[n: int; δ: float] =
Line 1,357:
echo " i δ"
for n, δ in feigenbaum():
echo fmt"{n:2d} {δ:.8f}"</langsyntaxhighlight>
 
{{out}}
Line 1,375:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use Math::AnyNum 'sqr';
Line 1,400:
($a2, $a1) = ($a1, $a);
printf "%2d %17.14f\n", $i, $d1;
}</langsyntaxhighlight>
{{out}}
<pre> 2 3.21851142203809
Line 1,417:
=={{header|Phix}}==
{{trans|Ring}}
<!--<langsyntaxhighlight Phixlang="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>
Line 1,440:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,460:
=={{header|Python}}==
{{trans|D}}
<langsyntaxhighlight lang="python">max_it = 13
max_it_j = 10
a1 = 1.0
Line 1,481:
d1 = d
a2 = a1
a1 = a</langsyntaxhighlight>
{{out}}
<pre> i d
Line 1,499:
=={{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 1,518:
 
(module+ main
(feigenbaum))</langsyntaxhighlight>
{{out}}
<pre> i d
Line 1,540:
{{trans|Ring}}
 
<syntaxhighlight lang="raku" perl6line>my $a1 = 1;
my $a2 = 0;
my $d = 3.2;
Line 1,560:
($a2, $a1) = ($a1, $a);
printf "%2d %.8f\n", $exp, $d;
}</langsyntaxhighlight>
{{out}}
<pre> i d
Line 1,578:
=={{header|REXX}}==
{{trans|Sidef}}
<langsyntaxhighlight 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 1,610:
/*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. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,641:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring"># Project : Feigenbaum constant calculation
 
decimals(8)
Line 1,671:
a2 = a1
a1 = a
next</langsyntaxhighlight>
Output:
<pre>Feigenbaum constant calculation:
Line 1,690:
=={{header|Ruby}}==
{{trans|C#}}
<langsyntaxhighlight lang="ruby">def main
maxIt = 13
maxItJ = 10
Line 1,716:
end
 
main()</langsyntaxhighlight>
{{out}}
<pre> i d
Line 1,734:
=={{header|Scala}}==
===Imperative, ugly===
<langsyntaxhighlight Scalalang="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)
Line 1,758:
}
 
}</langsyntaxhighlight>
===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)].
<langsyntaxhighlight Scalalang="scala">object Feigenbaum2 extends App {
private val (max_it, max_it_j) = (13, 10)
 
Line 1,794:
result.foreach { case (δ, i) => println(f"${i + 2}%2d $δ%.8f") }
 
}</langsyntaxhighlight>
 
=={{header|Sidef}}==
{{trans|Raku}}
<langsyntaxhighlight lang="ruby">var a1 = 1
var a2 = 0
var δ = 3.2.float
Line 1,817:
(a2, a1) = (a1, a0)
printf("%2d %.8f\n", i, δ)
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,841:
{{trans|C}}
 
<langsyntaxhighlight lang="swift">import Foundation
 
func feigenbaum(iterations: Int = 13) {
Line 1,875:
}
 
feigenbaum()</langsyntaxhighlight>
 
{{out}}
Line 1,895:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<langsyntaxhighlight lang="vbnet">Module Module1
 
Sub Main()
Line 1,923:
End Sub
 
End Module</langsyntaxhighlight>
{{out}}
<pre> i d
Line 1,941:
=={{header|Vlang}}==
{{trans|Go}}
<langsyntaxhighlight lang="vlang">fn feigenbaum() {
max_it, max_itj := 13, 10
mut a1, mut a2, mut d1 := 1.0, 0.0, 3.2
Line 1,963:
fn main() {
feigenbaum()
}</langsyntaxhighlight>
 
{{out}}
Line 1,985:
{{trans|Ring}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang="ecmascript">import "/fmt" for Fmt
 
var feigenbaum = Fn.new {
Line 2,013:
}
 
feigenbaum.call()</langsyntaxhighlight>
 
{{out}}
Line 2,034:
=={{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 2,048:
d1,a2,a1 = d,a1,a;
}
}();</langsyntaxhighlight>
{{out}}
<pre>
Thundergnat
10,327

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327532"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information