Metallic ratios: Difference between revisions

=={{header|C#|csharp}}==

{{libheader|System.Numerics}}Since the task description outlines how the results can be calculated using square roots for each B, this program not only calculates the results by iteration (as specified), it also checks each result with an independent result calculated by the indicated square root (for each B).

using static System.Console;

using BI = System.Numerics.BigInteger;

WriteLine("\nAu to 256 digits:"); WriteLine(t);

WriteLine("Iteration count: {0} Matched Sq.Rt Calc: {1}", k, t == doOne(1, 256)); }

{{out}}

<pre style="white-space:pre-wrap;">Metal B Sq.Rt Iters /---- 32 decimal place value ----\ Matches Sq.Rt Calc

{{Works with|C++11}}

{{libheader|Boost}}

#include <iostream>

 

 

return 0;

{{Out}}

<pre>Lucas sequence for Platinum ratio, where b = 0:

 

=={{header|F_Sharp|F#}}==

// Metallic Ration. Nigel Galloway: September 16th., 2020

let rec fN i g (e,l)=match i with 0->g |_->fN (i-1) (int(l/e)::g) (e,(l%e)*10I)

let Σ,n=fG(fI n)(fN (g+1) []) in printf "required %d iterations -> %d." Σ n.Head; List.iter(printf "%d")n.Tail ;printfn ""

[0..9]|>Seq.iter(fun n->mR n 32; printfn ""); mR 1 256

{{out}}

<pre>

 

=={{header|Factor}}==

math prettyprint qw sequences ;

IN: rosetta-code.metallic-ratios

[ "- reached after %d iteration(s)\n\n" printf ]

} spread

{{out}}

<pre style="height:45ex">

 

=={{header|Go}}==

 

import (

fmt.Println("Golden ratio, where b = 1:")

metallic(1, 256)

 

{{out}}

=={{header|Groovy}}==

{{trans|Kotlin}}

private static List<String> names = new ArrayList<>()

static {

metallic(1, 256)

}

{{out}}

<pre>Lucas sequence for Platinum ratio, where b = 0

It's perhaps worth noting that we can compute the fibonacci ratio to 256 digits in ten iterations, if we use an appropriate form of iteration:

 

258j256":%~/+/+/ .*~^:10 x:*i.2 2

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

 

However, the task implies we should use a different form of iteration, so we should probably stick to that here.

 

task=:{{

32 task y

seq=1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

615 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

 

=={{header|Java}}==

import java.math.BigDecimal;

import java.math.BigInteger;

}

{{out}}

<pre>

Golden ratio, where b = 1:

Value to 256 decimal places after 615 iterations : 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

</pre>

 

=={{header|Julia}}==

import Base.iterate, Base.IteratorSize, Base.IteratorEltype, Base.Iterators.take

 

println("Golden ratio to 256 decimal places:")

metallic(1, 256)

<pre>

The first 15 elements of the Lucas sequence named Platinum and b of 0 are:

=={{header|Kotlin}}==

{{trans|Go}}

import java.math.BigInteger

 

println("Golden ration, where b = 1:")

metallic(1, 256)

{{out}}

<pre>Lucas sequence for Platinum ratio, where b = 0:

 

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

FindMetallicRatio[b_, digits_] :=

Module[{n, m, data, acc, old, done = False},

out = FindMetallicRatio[1, 256];

out["steps"]

{{out}}

<pre>b=0

=={{header|Nim}}==

{{libheader|bignum}}

import bignum

 

 

echo "Golden ratio where b = 1:"

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use feature qw(say state);

}

 

{{out}}

<pre>'Lucas' sequence for Platinum ratio, where b = 0:

{{trans|Go}}

{{libheader|Phix/mpfr}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

The final 258 digits includes the "1.", and dp+2 was needed on ratio to exactly match the Go (etc) output.

 

=={{header|Python}}==

from _pydecimal import getcontext, Decimal

 

 

print(f'\nb = 1 with 256 digits:')

{{out}}

<pre>b = 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

after 613 iterations:

1.618033988749894848204586834365638117720309179805762862135448622705260462818902449707207204189391137484754088075386891752126633862223536931793180060766726354433389086595939582905638322661319928290267880675208766892501711696207032221043216269548626296313614

</pre>

 

Note: Arrays, Lists and Sequences are zero indexed in Raku.

 

use Lingua::EN::Numbers;

 

 

# Stretch goal

{{out}}

<pre>Lucas sequence for Platinum ratio; where b = 0:

=={{header|REXX}}==

For this task, &nbsp; the elements of the Lucas sequence are zero based.

parse arg n bLO bHI digs . /*obtain optional arguments from the CL*/

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

say 'the' @approx "value reached after" #-1 " iterations with " digs @DecDigs

say r; say /*display the ration plus a blank line.*/

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

 

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

</pre>

=={{header|Ruby}}==

{{works with|Ruby|2.3}}

require('bigdecimal/util')

 

puts('%-9s %1s %3s %s' % ['name', 'b', 'n', 'ratio'])

gold_rn = metallic_ratio(1, 256)

{{out}}

<pre>Lucas Sequences...

 

=={{header|Sidef}}==

1..Inf -> reduce {|t,n|

var r = (f(n+1)/f(n)).round(-places)

say "Approximated value: #{v}"

say "Reached after #{n} iterations"

{{out}}

<pre>

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

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>Metal B Sq.Rt Iters /---- 32 decimal place value ----\\ Matches Sq.Rt Calc

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

 

var names = ["Platinum", "Golden", "Silver", "Bronze", "Copper","Nickel", "Aluminium", "Iron", "Tin", "Lead"]

}

System.print("Golden ratio, where b = 1:")

 

{{out}}

=={{header|zkl}}==

{{libheader|GMP}} GNU Multiple Precision Arithmetic Library

fcn lucasSeq(b){

Walker.zero().tweak('wrap(xs){

b,mr = c,mr2;

}

foreach metal in (metals.split(" ")){ n:=__metalWalker.idx;

println("\nLucas sequence for %s ratio; where b = %d:".fmt(metal,n));

mr,i := metallicRatio(lucasSeq(n));

println("Approximated value: %s - Reached after ~%d iterations.".fmt(mr,i));

{{out}}

<pre style="height:45ex">

Approximated value: 9.10977222864644365500113714088140 - Reached after ~19 iterations.

</pre>

mr,i := metallicRatio(lucasSeq(1),256);

{{out}}

<pre>