aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Metallic-ratios/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Metallic_ratios

153
Task/Metallic-ratios/00-TASK.txt Normal file
View file

@ -0,0 +1,153 @@
Many people have heard of the '''Golden ratio''', phi ('''φ'''). Phi is just one of a series
of related ratios that are referred to as the "'''Metallic ratios'''".
The '''Golden ratio''' was discovered and named by ancient civilizations as it was
thought to be the most pure and beautiful (like Gold). The '''Silver ratio''' was was
also known to the early Greeks, though was not named so until later as a nod to
the '''Golden ratio''' to which it is closely related. The series has been extended to
encompass all of the related ratios and was given the general name '''Metallic ratios''' (or ''Metallic means'').
''Somewhat incongruously as the original Golden ratio referred to the adjective "golden" rather than the metal "gold".''
'''Metallic ratios''' are the real roots of the general form equation:
<big> x<sup>2</sup> - bx - 1 = 0 </big>
where the integer '''b''' determines which specific one it is.
Using the quadratic equation:
<big> ( -b ± √(b<sup>2</sup> - 4ac) ) / 2a = x </big>
Substitute in (from the top equation) '''1''' for '''a''', '''-1''' for '''c''', and recognising that -b is negated we get:
<big> ( b ± √(b<sup>2</sup> + 4) ) ) / 2 = x </big>
We only want the real root:
<big> ( b + √(b<sup>2</sup> + 4) ) ) / 2 = x </big>
When we set '''b''' to '''1''', we get an irrational number: the '''Golden ratio'''.
<big> ( 1 + √(1<sup>2</sup> + 4) ) / 2 = (1 + √5) / 2 = ~1.618033989... </big>
With '''b''' set to '''2''', we get a different irrational number: the '''Silver ratio'''.
<big> ( 2 + √(2<sup>2</sup> + 4) ) / 2 = (2 + √8) / 2 = ~2.414213562... </big>
When the ratio '''b''' is '''3''', it is commonly referred to as the '''Bronze''' ratio, '''4''' and '''5'''
are sometimes called the '''Copper''' and '''Nickel''' ratios, though they aren't as
standard. After that there isn't really any attempt at standardized names. They
are given names here on this page, but consider the names fanciful rather than
canonical.
Note that technically, '''b''' can be '''0''' for a "smaller" ratio than the '''Golden ratio'''.
We will refer to it here as the '''Platinum ratio''', though it is kind-of a
degenerate case.
'''Metallic ratios''' where '''b''' > '''0''' are also defined by the irrational continued fractions:
<big> [b;b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b...] </big>
So, The first ten '''Metallic ratios''' are:
:::::: {| class="wikitable" style="text-align: center;"
|+ Metallic ratios
!Name!!'''b'''!!Equation!!Value!!Continued fraction!!OEIS link
|-
|Platinum||0||(0 + √4) / 2|| 1||-||-
|-
|Golden||1||(1 + √5) / 2|| 1.618033988749895...||[1;1,1,1,1,1,1,1,1,1,1...]||[[OEIS:A001622]]
|-
|Silver||2||(2 + √8) / 2|| 2.414213562373095...||[2;2,2,2,2,2,2,2,2,2,2...]||[[OEIS:A014176]]
|-
|Bronze||3||(3 + √13) / 2|| 3.302775637731995...||[3;3,3,3,3,3,3,3,3,3,3...]||[[OEIS:A098316]]
|-
|Copper||4||(4 + √20) / 2|| 4.23606797749979...||[4;4,4,4,4,4,4,4,4,4,4...]||[[OEIS:A098317]]
|-
|Nickel||5||(5 + √29) / 2|| 5.192582403567252...||[5;5,5,5,5,5,5,5,5,5,5...]||[[OEIS:A098318]]
|-
|Aluminum||6||(6 + √40) / 2|| 6.16227766016838...||[6;6,6,6,6,6,6,6,6,6,6...]||[[OEIS:A176398]]
|-
|Iron||7||(7 + √53) / 2|| 7.140054944640259...||[7;7,7,7,7,7,7,7,7,7,7...]||[[OEIS:A176439]]
|-
|Tin||8||(8 + √68) / 2|| 8.123105625617661...||[8;8,8,8,8,8,8,8,8,8,8...]||[[OEIS:A176458]]
|-
|Lead||9||(9 + √85) / 2|| 9.109772228646444...||[9;9,9,9,9,9,9,9,9,9,9...]||[[OEIS:A176522]]
|}
<hr>
There are other ways to find the '''Metallic ratios'''; one, (the focus of this task)
is through '''successive approximations of Lucas sequences'''.
A traditional '''Lucas sequence''' is of the form:
<big>x<sub>''n''</sub> = P * x<sub>''n-1''</sub> - Q * x<sub>''n-2''</sub></big>
and starts with the first 2 values '''0, 1'''.
For our purposes in this task, to find the metallic ratios we'll use the form:
<big>x<sub>''n''</sub> = b * x<sub>''n-1''</sub> + x<sub>''n-2''</sub></big>
( '''P''' is set to '''b''' and '''Q''' is set to '''-1'''. ) To avoid "divide by zero" issues we'll start the sequence with the first two terms '''1, 1'''. The initial starting value has very little effect on the final ratio or convergence rate. ''Perhaps it would be more accurate to call it a Lucas-like sequence.''
At any rate, when '''b = 1''' we get:
<big>x<sub>''n''</sub> = x<sub>''n-1''</sub> + x<sub>''n-2''</sub></big>
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...
more commonly known as the Fibonacci sequence.
When '''b = 2''':
<big>x<sub>''n''</sub> = 2 * x<sub>''n-1''</sub> + x<sub>''n-2''</sub></big>
1, 1, 3, 7, 17, 41, 99, 239, 577, 1393...
And so on.
To find the ratio by successive approximations, divide the ('''n+1''')th term by the
'''n'''th. As '''n''' grows larger, the ratio will approach the '''b''' metallic ratio.
For '''b = 1''' (Fibonacci sequence):
1/1 = 1
2/1 = 2
3/2 = 1.5
5/3 = 1.666667
8/5 = 1.6
13/8 = 1.625
21/13 = 1.615385
34/21 = 1.619048
55/34 = 1.617647
89/55 = 1.618182
etc.
It converges, but pretty slowly. In fact, the '''Golden ratio''' has the slowest
possible convergence for any irrational number.
;Task
For each of the first '''10 Metallic ratios'''; '''b''' = '''0''' through '''9''':
* Generate the corresponding "Lucas" sequence.
* Show here, on this page, at least the first '''15''' elements of the "Lucas" sequence.
* Using successive approximations, calculate the value of the ratio accurate to '''32''' decimal places.
* Show the '''value''' of the '''approximation''' at the required accuracy.
* Show the '''value''' of '''n''' when the approximation reaches the required accuracy (How many iterations did it take?).
Optional, stretch goal - Show the '''value''' and number of iterations '''n''', to approximate the '''Golden ratio''' to '''256''' decimal places.
You may assume that the approximation has been reached when the next iteration does not cause the value (to the desired places) to change.
;See also
* [[wp:Metallic_mean|Wikipedia: Metallic mean]]
* [[wp:Lucas_sequence|Wikipedia: Lucas sequence]]

49
Task/Metallic-ratios/C++/metallic-ratios.cpp Normal file
View file

@ -0,0 +1,49 @@
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <iostream>
const char* names[] = { "Platinum", "Golden", "Silver", "Bronze", "Copper", "Nickel", "Aluminium", "Iron", "Tin", "Lead" };
template<const uint N>
void lucas(ulong b) {
std::cout << "Lucas sequence for " << names[b] << " ratio, where b = " << b << ":\nFirst " << N << " elements: ";
auto x0 = 1L, x1 = 1L;
std::cout << x0 << ", " << x1;
for (auto i = 1u; i <= N - 1 - 1; i++) {
auto x2 = b * x1 + x0;
std::cout << ", " << x2;
x0 = x1;
x1 = x2;
}
std::cout << std::endl;
}
template<const ushort P>
void metallic(ulong b) {
using namespace boost::multiprecision;
using bfloat = number<cpp_dec_float<P+1>>;
bfloat x0(1), x1(1);
auto prev = bfloat(1).str(P+1);
for (auto i = 0u;;) {
i++;
bfloat x2(b * x1 + x0);
auto thiz = bfloat(x2 / x1).str(P+1);
if (prev == thiz) {
std::cout << "Value after " << i << " iteration" << (i == 1 ? ": " : "s: ") << thiz << std::endl << std::endl;
break;
}
prev = thiz;
x0 = x1;
x1 = x2;
}
}
int main() {
for (auto b = 0L; b < 10L; b++) {
lucas<15>(b);
metallic<32>(b);
}
std::cout << "Golden ratio, where b = 1:" << std::endl;
metallic<256>(1);
return 0;
}

45
Task/Metallic-ratios/C-sharp/metallic-ratios.cs Normal file
View file

@ -0,0 +1,45 @@
using static System.Math;
using static System.Console;
using BI = System.Numerics.BigInteger;
class Program {
static BI IntSqRoot(BI v, BI res) { // res is the initial guess
BI term = 0, d = 0, dl = 1; while (dl != d) { term = v / res; res = (res + term) >> 1;
dl = d; d = term - res; } return term; }
static string doOne(int b, int digs) { // calculates result via square root, not iterations
int s = b * b + 4; BI g = (BI)(Sqrt((double)s) * Pow(10, ++digs)),
bs = IntSqRoot(s * BI.Parse('1' + new string('0', digs << 1)), g);
bs += b * BI.Parse('1' + new string('0', digs));
bs >>= 1; bs += 4; string st = bs.ToString();
return string.Format("{0}.{1}", st[0], st.Substring(1, --digs)); }
static string divIt(BI a, BI b, int digs) { // performs division
int al = a.ToString().Length, bl = b.ToString().Length;
a *= BI.Pow(10, ++digs << 1); b *= BI.Pow(10, digs);
string s = (a / b + 5).ToString(); return s[0] + "." + s.Substring(1, --digs); }
// custom formating
static string joined(BI[] x) { int[] wids = {1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
string res = ""; for (int i = 0; i < x.Length; i++) res +=
string.Format("{0," + (-wids[i]).ToString() + "} ", x[i]); return res; }
static void Main(string[] args) { // calculates and checks each "metal"
WriteLine("Metal B Sq.Rt Iters /---- 32 decimal place value ----\\ Matches Sq.Rt Calc");
int k; string lt, t = ""; BI n, nm1, on; for (int b = 0; b < 10; b++) {
BI[] lst = new BI[15]; lst[0] = lst[1] = 1;
for (int i = 2; i < 15; i++) lst[i] = b * lst[i - 1] + lst[i - 2];
// since all the iterations (except Pt) are > 15, continue iterating from the end of the list of 15
n = lst[14]; nm1 = lst[13]; k = 0; for (int j = 13; k == 0; j++) {
lt = t; if (lt == (t = divIt(n, nm1, 32))) k = b == 0 ? 1 : j;
on = n; n = b * n + nm1; nm1 = on; }
WriteLine("{0,4} {1} {2,2} {3, 2} {4} {5}\n{6,19} {7}", "Pt Au Ag CuSn Cu Ni Al Fe Sn Pb"
.Split(' ')[b], b, b * b + 4, k, t, t == doOne(b, 32), "", joined(lst)); }
// now calculate and check big one
n = nm1 =1; k = 0; for (int j = 1; k == 0; j++) {
lt = t; if (lt == (t = divIt(n, nm1, 256))) k = j;
on = n; n += nm1; nm1 = on; }
WriteLine("\nAu to 256 digits:"); WriteLine(t);
WriteLine("Iteration count: {0} Matched Sq.Rt Calc: {1}", k, t == doOne(1, 256)); }
}

7
Task/Metallic-ratios/F-Sharp/metallic-ratios.fs Normal file
View file

@ -0,0 +1,7 @@
// 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 fI(P:int)=Seq.unfold(fun(n,g)->Some(g,((bigint P)*n+g,n)))(1I,1I)
let fG fI fN=let _,(n,g)=fI|>Seq.pairwise|>Seq.mapi(fun n g->(n,fN g))|>Seq.pairwise|>Seq.find(fun((_,n),(_,g))->n=g) in (n,List.rev g)
let mR n g=printf "First 15 elements when P = %d -> " n; fI n|>Seq.take 15|>Seq.iter(printf "%A "); printf "\n%d decimal places " g
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

29
Task/Metallic-ratios/Factor/metallic-ratios.factor Normal file
View file

@ -0,0 +1,29 @@
USING: combinators decimals formatting generalizations io kernel
math prettyprint qw sequences ;
IN: rosetta-code.metallic-ratios
: lucas ( n a b -- n a' b' ) tuck reach * + ;
: lucas. ( n -- )
1 pprint bl 1 1 14 [ lucas over pprint bl ] times 3drop nl ;
: approx ( a b -- d ) swap [ 0 <decimal> ] bi@ 32 D/ ;
: approximate ( n -- value iter )
-1 swap 1 1 0 1 [ 2dup = ]
[ [ 1 + ] 5 ndip [ lucas 2dup approx ] 2dip drop ] until
4nip decimal>ratio swap ;
qw{
Platinum Golden Silver Bronze Copper Nickel Aluminum Iron
Tin Lead
}
[
dup dup approximate {
[ "Lucas sequence for %s ratio " printf ]
[ "where b = %d:\n" printf ]
[ "First 15 elements: " write lucas. ]
[ "Approximated value: %.32f " printf ]
[ "- reached after %d iteration(s)\n\n" printf ]
} spread
] each-index

55
Task/Metallic-ratios/Go/metallic-ratios.go Normal file
View file

@ -0,0 +1,55 @@
package main
import (
"fmt"
"math/big"
)
var names = [10]string{"Platinum", "Golden", "Silver", "Bronze", "Copper",
"Nickel", "Aluminium", "Iron", "Tin", "Lead"}
func lucas(b int64) {
fmt.Printf("Lucas sequence for %s ratio, where b = %d:\n", names[b], b)
fmt.Print("First 15 elements: ")
var x0, x1 int64 = 1, 1
fmt.Printf("%d, %d", x0, x1)
for i := 1; i <= 13; i++ {
x2 := b*x1 + x0
fmt.Printf(", %d", x2)
x0, x1 = x1, x2
}
fmt.Println()
}
func metallic(b int64, dp int) {
x0, x1, x2, bb := big.NewInt(1), big.NewInt(1), big.NewInt(0), big.NewInt(b)
ratio := big.NewRat(1, 1)
iters := 0
prev := ratio.FloatString(dp)
for {
iters++
x2.Mul(bb, x1)
x2.Add(x2, x0)
this := ratio.SetFrac(x2, x1).FloatString(dp)
if prev == this {
plural := "s"
if iters == 1 {
plural = " "
}
fmt.Printf("Value to %d dp after %2d iteration%s: %s\n\n", dp, iters, plural, this)
return
}
prev = this
x0.Set(x1)
x1.Set(x2)
}
}
func main() {
for b := int64(0); b < 10; b++ {
lucas(b)
metallic(b, 32)
}
fmt.Println("Golden ratio, where b = 1:")
metallic(1, 256)
}

65
Task/Metallic-ratios/Groovy/metallic-ratios.groovy Normal file
View file

@ -0,0 +1,65 @@
class MetallicRatios {
private static List<String> names = new ArrayList<>()
static {
names.add("Platinum")
names.add("Golden")
names.add("Silver")
names.add("Bronze")
names.add("Copper")
names.add("Nickel")
names.add("Aluminum")
names.add("Iron")
names.add("Tin")
names.add("Lead")
}
private static void lucas(long b) {
printf("Lucas sequence for %s ratio, where b = %d\n", names[b], b)
print("First 15 elements: ")
long x0 = 1
long x1 = 1
printf("%d, %d", x0, x1)
for (int i = 1; i < 13; ++i) {
long x2 = b * x1 + x0
printf(", %d", x2)
x0 = x1
x1 = x2
}
println()
}
private static void metallic(long b, int dp) {
BigInteger x0 = BigInteger.ONE
BigInteger x1 = BigInteger.ONE
BigInteger x2
BigInteger bb = BigInteger.valueOf(b)
BigDecimal ratio = BigDecimal.ONE.setScale(dp)
int iters = 0
String prev = ratio.toString()
while (true) {
iters++
x2 = bb * x1 + x0
String thiz = (x2.toBigDecimal().setScale(dp) / x1.toBigDecimal().setScale(dp)).toString()
if (prev == thiz) {
String plural = "s"
if (iters == 1) {
plural = ""
}
printf("Value after %d iteration%s: %s\n\n", iters, plural, thiz)
return
}
prev = thiz
x0 = x1
x1 = x2
}
}
static void main(String[] args) {
for (int b = 0; b < 10; ++b) {
lucas(b)
metallic(b, 32)
}
println("Golden ratio, where b = 1:")
metallic(1, 256)
}
}

2
Task/Metallic-ratios/J/metallic-ratios-1.j Normal file
View file

@ -0,0 +1,2 @@
258j256":%~/+/+/ .*~^:10 x:*i.2 2
1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

62
Task/Metallic-ratios/J/metallic-ratios-2.j Normal file
View file

@ -0,0 +1,62 @@
task=:{{
32 task y
:
echo 'b=',":y
echo 'seq=',":(,(1,y) X _2{.])^:15]1 1x
k=. 0
prev=.val=. ''
rat=. 1 1x
whilst.-.prev-:val do.
k=. k+1
prev=. val
rat=. }.rat,rat X 1,y
val=. (j./2 0+x)":%~/rat
end.
echo (":k),' iterations: ',val
}}
task 0
b=0
seq=1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 iterations: 1.00000000000000000000000000000000
task 1
b=1
seq=1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
78 iterations: 1.61803398874989484820458683436564
task 2
b=2
seq=1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243 275807 665857
44 iterations: 2.41421356237309504880168872420970
task 3
b=3
seq=1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564 21932293 72437443
34 iterations: 3.30277563773199464655961063373525
task 4
b=4
seq=1 1 5 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141 701408733 2971215073
28 iterations: 4.23606797749978969640917366873128
task 5
b=5
seq=1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686 11913527111 61861971241
25 iterations: 5.19258240356725201562535524577016
task 6
b=6
seq=1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775 128943316987 794584521697
23 iterations: 6.16227766016837933199889354443272
task 7
b=7
seq=1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408 1000716717057 7145172343807
22 iterations: 7.14005494464025913554865124576352
task 8
b=8
seq=1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449 6025563297593 48946287120193
20 iterations: 8.12310562561766054982140985597408
task 9
b=9
seq=1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226 29726047448083 270797521509973
20 iterations: 9.10977222864644365500113714088140
256 task 1
b=1
seq=1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
615 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

70
Task/Metallic-ratios/Java/metallic-ratios.java Normal file
View file

@ -0,0 +1,70 @@
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.ArrayList;
import java.util.List;
public class MetallicRatios {
private static String[] ratioDescription = new String[] {"Platinum", "Golden", "Silver", "Bronze", "Copper", "Nickel", "Aluminum", "Iron", "Tin", "Lead"};
public static void main(String[] args) {
int elements = 15;
for ( int b = 0 ; b < 10 ; b++ ) {
System.out.printf("Lucas sequence for %s ratio, where b = %d:%n", ratioDescription[b], b);
System.out.printf("First %d elements: %s%n", elements, lucasSequence(1, 1, b, elements));
int decimalPlaces = 32;
BigDecimal[] ratio = lucasSequenceRatio(1, 1, b, decimalPlaces+1);
System.out.printf("Value to %d decimal places after %s iterations : %s%n", decimalPlaces, ratio[1], ratio[0]);
System.out.printf("%n");
}
int b = 1;
int decimalPlaces = 256;
System.out.printf("%s ratio, where b = %d:%n", ratioDescription[b], b);
BigDecimal[] ratio = lucasSequenceRatio(1, 1, b, decimalPlaces+1);
System.out.printf("Value to %d decimal places after %s iterations : %s%n", decimalPlaces, ratio[1], ratio[0]);
}
private static BigDecimal[] lucasSequenceRatio(int x0, int x1, int b, int digits) {
BigDecimal x0Bi = BigDecimal.valueOf(x0);
BigDecimal x1Bi = BigDecimal.valueOf(x1);
BigDecimal bBi = BigDecimal.valueOf(b);
MathContext mc = new MathContext(digits);
BigDecimal fractionPrior = x1Bi.divide(x0Bi, mc);
int iterations = 0;
while ( true ) {
iterations++;
BigDecimal x = bBi.multiply(x1Bi).add(x0Bi);
BigDecimal fractionCurrent = x.divide(x1Bi, mc);
if ( fractionCurrent.compareTo(fractionPrior) == 0 ) {
break;
}
x0Bi = x1Bi;
x1Bi = x;
fractionPrior = fractionCurrent;
}
return new BigDecimal[] {fractionPrior, BigDecimal.valueOf(iterations)};
}
private static List<BigInteger> lucasSequence(int x0, int x1, int b, int n) {
List<BigInteger> list = new ArrayList<>();
BigInteger x0Bi = BigInteger.valueOf(x0);
BigInteger x1Bi = BigInteger.valueOf(x1);
BigInteger bBi = BigInteger.valueOf(b);
if ( n > 0 ) {
list.add(x0Bi);
}
if ( n > 1 ) {
list.add(x1Bi);
}
while ( n > 2 ) {
BigInteger x = bBi.multiply(x1Bi).add(x0Bi);
list.add(x);
n--;
x0Bi = x1Bi;
x1Bi = x;
}
return list;
}
}

38
Task/Metallic-ratios/Jq/metallic-ratios.jq Normal file
View file

@ -0,0 +1,38 @@
include "rational" {search: "."}; the defs at [[Arithmetic/Rational#jq]]
def names:
["Platinum", "Golden", "Silver", "Bronze", "Copper","Nickel", "Aluminium", "Iron", "Tin", "Lead"];
def lucas($b):
[1,1] | recurse( [last, first + $b*last] ) | first;
def lucas($b; $n):
"Lucas sequence for \(names[$b]) ratio, where b = \($b):",
"First \(n) elements: ",
[limit($n; lucas($b))];
# dp = integer (degrees of precision)
def metallic(b; dp):
{ x0: 1,
x1: 1,
x2: 0,
ratio: r(1; 1),
iters: 0 }
| .prev = (.ratio|r_to_decimal(dp)) # a string
| until(.emit;
.iters += 1
| .x2 = .b * .x1 + .x0
| .ratio = r(.x2; .x1)
| .curr = (.ratio|r_to_decimal(dp)) # a string
| if .prev == .curr
then (if (.iters == 1) then " " else "s" end) as $plural
| .emit = "Value to \(dp) dp after \(.iters) iteration\($plural): \(.curr)\n"
else .prev = .curr
| .x0 = .x1
| .x1 = .x2
end )
| .emit;
(range( 0;10) | lucas(.; 15), metallic(.; 32)),
"Golden ratio, where b = 1:", metallic(1; 256)

36
Task/Metallic-ratios/Julia/metallic-ratios.julia Normal file
View file

@ -0,0 +1,36 @@
using Formatting
import Base.iterate, Base.IteratorSize, Base.IteratorEltype, Base.Iterators.take
const metallicnames = ["Platinum", "Golden", "Silver", "Bronze", "Copper", "Nickel",
"Aluminium", "Iron", "Tin", "Lead"]
struct Lucas b::Int end
Base.IteratorSize(s::Lucas) = Base.IsInfinite()
Base.IteratorEltype(s::Lucas) = BigInt
Base.iterate(s::Lucas, (x1, x2) = (big"1", big"1")) = (t = x2 * s.b + x1; (x1, (x2, t)))
printlucas(b, len=15) = (for i in take(Lucas(b), len) print(i, ", ") end; println("..."))
function lucasratios(b, len)
iter = BigFloat.(collect(take(Lucas(b), len + 1)))
return map(i -> iter[i + 1] / iter[i], 1:length(iter)-1)
end
function metallic(b, dplaces=32)
setprecision(dplaces * 5)
ratios, err = lucasratios(b, dplaces * 50), BigFloat(10)^(-dplaces)
errors = map(i -> abs(ratios[i + 1] - ratios[i]), 1:length(ratios)-1)
iternum = findfirst(x -> x < err, errors)
println("After $(iternum + 1) iterations, the value of ",
format(ratios[iternum + 1], precision=dplaces),
" is stable to $dplaces decimal places.\n")
end
for (b, name) in enumerate(metallicnames)
println("The first 15 elements of the Lucas sequence named ",
metallicnames[b], " and b of $(b - 1) are:")
printlucas(b - 1)
metallic(b - 1)
end
println("Golden ratio to 256 decimal places:")
metallic(1, 256)

54
Task/Metallic-ratios/Kotlin/metallic-ratios.kotlin Normal file
View file

@ -0,0 +1,54 @@
import java.math.BigDecimal
import java.math.BigInteger
val names = listOf("Platinum", "Golden", "Silver", "Bronze", "Copper", "Nickel", "Aluminium", "Iron", "Tin", "Lead")
fun lucas(b: Long) {
println("Lucas sequence for ${names[b.toInt()]} ratio, where b = $b:")
print("First 15 elements: ")
var x0 = 1L
var x1 = 1L
print("$x0, $x1")
for (i in 1..13) {
val x2 = b * x1 + x0
print(", $x2")
x0 = x1
x1 = x2
}
println()
}
fun metallic(b: Long, dp:Int) {
var x0 = BigInteger.ONE
var x1 = BigInteger.ONE
var x2: BigInteger
val bb = BigInteger.valueOf(b)
val ratio = BigDecimal.ONE.setScale(dp)
var iters = 0
var prev = ratio.toString()
while (true) {
iters++
x2 = bb * x1 + x0
val thiz = (x2.toBigDecimal(dp) / x1.toBigDecimal(dp)).toString()
if (prev == thiz) {
var plural = "s"
if (iters == 1) {
plural = ""
}
println("Value after $iters iteration$plural: $thiz\n")
return
}
prev = thiz
x0 = x1
x1 = x2
}
}
fun main() {
for (b in 0L until 10L) {
lucas(b)
metallic(b, 32)
}
println("Golden ration, where b = 1:")
metallic(1, 256)
}

32
Task/Metallic-ratios/Mathematica/metallic-ratios.math Normal file
View file

@ -0,0 +1,32 @@
ClearAll[FindMetallicRatio]
FindMetallicRatio[b_, digits_] :=
Module[{n, m, data, acc, old, done = False},
{n, m} = {1, 1};
old = -100;
data = {};
While[done == False,
{n, m} = {m, b m + n};
AppendTo[data, {m, m/n}];
If[Length[data] > 15,
If[-N[Log10[Abs[data[[-1, 2]] - data[[-2, 2]]]]] > digits,
done = True
]
]
];
acc = -N[Log10[Abs[data[[-1, 2]] - data[[-2, 2]]]]];
<|"sequence" -> Join[{1, 1}, data[[All, 1]]],
"ratio" -> data[[All, 2]], "acc" -> acc,
"steps" -> Length[data]|>
]
Do[
out = FindMetallicRatio[b, 32];
Print["b=", b];
Print["b=", b, " first 15=", Take[out["sequence"], 15]];
Print["b=", b, " ratio=", N[Last[out["ratio"]], {\[Infinity], 33}]];
Print["b=", b, " Number of steps=", out["steps"]];
,
{b, 0, 9}
]
out = FindMetallicRatio[1, 256];
out["steps"]
N[out["ratio"][[-1]], 256]

56
Task/Metallic-ratios/Nim/metallic-ratios.nim Normal file
View file

@ -0,0 +1,56 @@
import strformat
import bignum
type Metal {.pure.} = enum platinum, golden, silver, bronze, copper, nickel, aluminium, iron, tin, lead
iterator sequence(b: int): Int =
## Yield the successive terms if a “Lucas” sequence.
## The first two terms are ignored.
var x, y = newInt(1)
while true:
x += b * y
swap x, y
yield y
template plural(n: int): string =
if n >= 2: "s" else: ""
proc computeRatio(b: Natural; digits: Positive) =
## Compute the ratio for the given "n" with the required number of digits.
let M = 10^culong(digits)
var niter = 0 # Number of iterations.
var prevN = newInt(1) # Previous value of "n".
var ratio = M # Current value of ratio.
for n in sequence(b):
inc niter
let nextRatio = n * M div prevN
if nextRatio == ratio: break
prevN = n.clone
ratio = nextRatio
var str = $ratio
str.insert(".", 1)
echo &"Value to {digits} decimal places after {niter} iteration{plural(niter)}: ", str
when isMainModule:
for b in 0..9:
echo &"“Lucas” sequence for {Metal(b)} ratio where b = {b}:"
stdout.write "First 15 elements: 1 1"
var count = 2
for n in sequence(b):
stdout.write ' ', n
inc count
if count == 15: break
echo ""
computeRatio(b, 32)
echo ""
echo "Golden ratio where b = 1:"
computeRatio(1, 256)

39
Task/Metallic-ratios/Perl/metallic-ratios.pl Normal file
View file

@ -0,0 +1,39 @@
use strict;
use warnings;
use feature qw(say state);
use Math::AnyNum qw<:overload as_dec>;
sub gen_lucas {
my $b = shift;
my $i = 0;
return sub {
state @seq = (state $v1 = 1, state $v2 = 1);
($v2, $v1) = ($v1, $v2 + $b*$v1) and push(@seq, $v1) unless defined $seq[$i+1];
return $seq[$i++];
}
}
sub metallic {
my $lucas = shift;
my $places = shift || 32;
my $n = my $last = 0;
my @seq = $lucas->();
while (1) {
push @seq, $lucas->();
my $this = as_dec( $seq[-1]/$seq[-2], $places+1 );
last if $this eq $last;
$last = $this;
$n++;
}
$last, $n
}
my @name = <Platinum Golden Silver Bronze Copper Nickel Aluminum Iron Tin Lead>;
for my $b (0..$#name) {
my $lucas = gen_lucas($b);
printf "\n'Lucas' sequence for $name[$b] ratio, where b = $b:\nFirst 15 elements: " . join ', ', map { $lucas->() } 1..15;
printf "Approximated value %s reached after %d iterations\n", metallic(gen_lucas($b));
}
printf "\nGolden ratio to 256 decimal places %s reached after %d iterations", metallic(gen_lucas(1),256);

54
Task/Metallic-ratios/Phix/metallic-ratios.phix Normal file
View file

@ -0,0 +1,54 @@
(phixonline)-->
<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;">constant</span> <span style="color: #000000;">names</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"Platinum"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Golden"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Silver"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Bronze"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Copper"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"Nickel"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Aluminium"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Iron"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Tin"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Lead"</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">lucas</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">b</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;">"Lucas sequence for %s ratio, where b = %d:\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">names</span><span style="color: #0000FF;">[</span><span style="color: #000000;">b</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">})</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">x0</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x2</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;">"First 15 elements: %d, %d"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">x0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x1</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;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">13</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">x2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">*</span><span style="color: #000000;">x1</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">x0</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;">", %d"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x2</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">x0</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">x1</span>
<span style="color: #000000;">x1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">x2</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">metallic</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">dp</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">mpz</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">x0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">bb</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">})</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">ratio</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-(</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">+</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">iterations</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ratio</span><span style="color: #0000FF;">,</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">iterations</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #7060A8;">mpz_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">bb</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x0</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_set_z</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ratio</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_div_z</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ratio</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ratio</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">curr</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ratio</span><span style="color: #0000FF;">,</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">prev</span> <span style="color: #0000FF;">==</span> <span style="color: #000000;">curr</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">plural</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">iterations</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #008000;">""</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"s"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">curr</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curr</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;">"Value to %d dp after %2d iteration%s: %s\n\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">iterations</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">plural</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">curr</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">curr</span>
<span style="color: #7060A8;">mpz_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x2</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">9</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">lucas</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">metallic</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">32</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"Golden ratio, where b = 1:\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">metallic</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">256</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--

29
Task/Metallic-ratios/Python/metallic-ratios.py Normal file
View file

@ -0,0 +1,29 @@
from itertools import count, islice
from _pydecimal import getcontext, Decimal
def metallic_ratio(b):
m, n = 1, 1
while True:
yield m, n
m, n = m*b + n, m
def stable(b, prec):
def to_decimal(b):
for m,n in metallic_ratio(b):
yield Decimal(m)/Decimal(n)
getcontext().prec = prec
last = 0
for i,x in zip(count(), to_decimal(b)):
if x == last:
print(f'after {i} iterations:\n\t{x}')
break
last = x
for b in range(4):
coefs = [n for _,n in islice(metallic_ratio(b), 15)]
print(f'\nb = {b}: {coefs}')
stable(b, 32)
print(f'\nb = 1 with 256 digits:')
stable(1, 256)

43
Task/Metallic-ratios/Quackery/metallic-ratios.quackery Normal file
View file

@ -0,0 +1,43 @@
[ $ "bigrat.qky" loadfile ] now!
[ [ table
$ "Platinum" $ "Golden"
$ "Silver" $ "Bronze"
$ "Copper" $ "Nickel"
$ "Aluminium" $ "Iron"
$ "Tin" $ "Lead" ]
do echo$ ] is echoname ( n --> )
[ temp put
' [ 1 1 ]
13 times
[ dup -1 peek
temp share *
over -2 peek +
join ]
temp release ] is task1 ( n --> [ )
[ temp put
' [ 0 1 1 ]
[ dup -3 split nip
do dip tuck swap
32 approx= if done
dup -1 peek
temp share *
over -2 peek +
join
again ]
temp release
dup size 3 - swap
-3 split nip
-1 split drop
do swap rot ] is task2 ( n --> n/d n )
10 times
[ i^ echoname cr
i^ task1
witheach [ echo sp ] cr
i^ task2
echo sp
32 point$ echo$
cr cr ]

33
Task/Metallic-ratios/REXX/metallic-ratios.rexx Normal file
View file

@ -0,0 +1,33 @@
/*REXX pgm computes the 1st N elements of the Lucas sequence for Metallic ratios 0──►9. */
parse arg n bLO bHI digs . /*obtain optional arguments from the CL*/
if n=='' | n=="," then n= 15 /*Not specified? Then use the default.*/
if bLO=='' | bLO=="," then bLO= 0 /* " " " " " " */
if bHI=='' | bHI=="," then bHI= 9 /* " " " " " " */
if digs=='' | digs=="," then digs= 32 /* " " " " " " */
numeric digits digs + length(.) /*specify number of decimal digs to use*/
metals= 'platinum golden silver bronze copper nickel aluminum iron tin lead'
@decDigs= ' decimal digits past the decimal point:' /*a literal used in SAY.*/
!.= /*the default name for a metallic ratio*/
do k=0 to 9; !.k= word(metals, k+1) /*assign the (ten) metallic ratio names*/
end /*k*/
do m=bLO to bHI; @.= 1; $= 1 1 /*compute the sequence numbers & ratios*/
r=. /*the ratio (so far). */
do #=2 until r=old; old= r /*compute sequence numbers & the ratio.*/
#_1= #-1; #_2= #-2 /*use variables for previous numbers. */
@.#= m * @.#_1 + @.#_2 /*calculate a number i the sequence. */
if #<n then $= $ @.# /*build a sequence list of N numbers.*/
r= @.# / @.#_1 /*calculate ratio of the last 2 numbers*/
end /*#*/
if words($)<n then $= subword($ copies('1 ', n), 1, n) /*extend list if too short*/
L= max(108, length($) ) /*ensure width of title. */
say center(' Lucas sequence for the' !.m "ratio, where B is " m' ', L, "═")
if n>0 then do; say 'the first ' n " elements are:"; say $
end /*if N is positive, then show N nums.*/
@approx= 'approximate' /*literal (1 word) that is used for SAY*/
r= format(r,,digs) /*limit decimal digits for R to digs.*/
if datatype(r, 'W') then do; r= r/1; @approx= "exact"; end
say 'the' @approx "value reached after" #-1 " iterations with " digs @DecDigs
say r; say /*display the ration plus a blank line.*/
end /*m*/ /*stick a fork in it, we're all done. */

33
Task/Metallic-ratios/Raku/metallic-ratios.raku Normal file
View file

@ -0,0 +1,33 @@
use Rat::Precise;
use Lingua::EN::Numbers;
sub lucas ($b) { 1, 1, * + $b * * … * }
sub metallic ($seq, $places = 32) {
my $n = 0;
my $last = 0;
loop {
my $approx = FatRat.new($seq[$n + 1], $seq[$n]);
my $this = $approx.precise($places, :z);
last if $this eq $last;
$last = $this;
$n++;
}
$last, $n
}
sub display ($value, $n) {
"Approximated value:", $value, "Reached after {$n} iterations: " ~
"{ordinal-digit $n}/{ordinal-digit $n - 1} element."
}
for <Platinum Golden Silver Bronze Copper Nickel Aluminum Iron Tin Lead>.kv
-> \b, $name {
my $lucas = lucas b;
print "\nLucas sequence for $name ratio; where b = {b}:\nFirst 15 elements: ";
say join ', ', $lucas[^15];
say join ' ', display |metallic($lucas);
}
# Stretch goal
say join "\n", "\nGolden ratio to 256 decimal places:", display |metallic lucas(1), 256;

61
Task/Metallic-ratios/Ruby/metallic-ratios.rb Normal file
View file

@ -0,0 +1,61 @@
require('bigdecimal')
require('bigdecimal/util')
# An iterator over the Lucas Sequence for 'b'.
# (The special case of: x(n) = b * x(n-1) + x(n-2).)
def lucas(b)
Enumerator.new do |yielder|
xn2 = 1 ; yielder.yield(xn2)
xn1 = 1 ; yielder.yield(xn1)
loop { xn2, xn1 = xn1, b * xn1 + xn2 ; yielder.yield(xn1) }
end
end
# Compute the Metallic Ratio to 'precision' from the Lucas Sequence for 'b'.
# (Uses the lucas(b) iterator, above.)
# The metallic ratio is approximated by x(n) / x(n-1).
# Returns a struct of the approximate metallic ratio (.ratio) and the
# number of terms required to achieve the given precision (.terms).
def metallic_ratio(b, precision)
xn2 = xn1 = prev = this = 0
lucas(b).each.with_index do |xn, inx|
case inx
when 0
xn2 = BigDecimal(xn)
when 1
xn1 = BigDecimal(xn)
prev = xn1.div(xn2, 2 * precision).round(precision)
else
xn2, xn1 = xn1, BigDecimal(xn)
this = xn1.div(xn2, 2 * precision).round(precision)
return Struct.new(:ratio, :terms).new(prev, inx - 1) if prev == this
prev = this
end
end
end
NAMES = [ 'Platinum', 'Golden', 'Silver', 'Bronze', 'Copper',
'Nickel', 'Aluminum', 'Iron', 'Tin', 'Lead' ]
puts
puts('Lucas Sequences...')
puts('%1s %s' % ['b', 'sequence'])
(0..9).each do |b|
puts('%1d %s' % [b, lucas(b).first(15)])
end
puts
puts('Metallic Ratios to 32 places...')
puts('%-9s %1s %3s %s' % ['name', 'b', 'n', 'ratio'])
(0..9).each do |b|
rn = metallic_ratio(b, 32)
puts('%-9s %1d %3d %s' % [NAMES[b], b, rn.terms, rn.ratio.to_s('F')])
end
puts
puts('Golden Ratio to 256 places...')
puts('%-9s %1s %3s %s' % ['name', 'b', 'n', 'ratio'])
gold_rn = metallic_ratio(1, 256)
puts('%-9s %1d %3d %s' % [NAMES[1], 1, gold_rn.terms, gold_rn.ratio.to_s('F')])

23
Task/Metallic-ratios/Sidef/metallic-ratios.sidef Normal file
View file

@ -0,0 +1,23 @@
func seqRatio(f, places = 32) {
1..Inf -> reduce {|t,n|
var r = (f(n+1)/f(n)).round(-places)
return(n, r.as_dec(places + r.abs.int.len)) if (r == t)
r
}
}
for k,v in (%w(Platinum Golden Silver Bronze Copper Nickel Aluminum Iron Tin Lead).kv) {
next if (k == 0) # undefined ratio
say "Lucas sequence U_n(#{k},-1) for #{v} ratio"
var f = {|n| lucasu(k, -1, n) }
say ("First 15 elements: ", 15.of(f).join(', '))
var (n, r) = seqRatio(f)
say "Approximated value: #{r} reached after #{n} iterations"
say ''
}
with (seqRatio({|n| fib(n) }, 256)) {|n,v|
say "Golden ratio to 256 decimal places:"
say "Approximated value: #{v}"
say "Reached after #{n} iterations"
}

112
Task/Metallic-ratios/Visual-Basic-.NET/metallic-ratios.vb Normal file
View file

@ -0,0 +1,112 @@
Imports BI = System.Numerics.BigInteger
Module Module1
Function IntSqRoot(v As BI, res As BI) As BI
REM res is the initial guess
Dim term As BI = 0
Dim d As BI = 0
Dim dl As BI = 1
While dl <> d
term = v / res
res = (res + term) >> 1
dl = d
d = term - res
End While
Return term
End Function
Function DoOne(b As Integer, digs As Integer) As String
REM calculates result via square root, not iterations
Dim s = b * b + 4
digs += 1
Dim g As BI = Math.Sqrt(s * Math.Pow(10, digs))
Dim bs = IntSqRoot(s * BI.Parse("1" + New String("0", digs << 1)), g)
bs += b * BI.Parse("1" + New String("0", digs))
bs >>= 1
bs += 4
Dim st = bs.ToString
digs -= 1
Return String.Format("{0}.{1}", st(0), st.Substring(1, digs))
End Function
Function DivIt(a As BI, b As BI, digs As Integer) As String
REM performs division
Dim al = a.ToString.Length
Dim bl = b.ToString.Length
digs += 1
a *= BI.Pow(10, digs << 1)
b *= BI.Pow(10, digs)
Dim s = (a / b + 5).ToString
digs -= 1
Return s(0) + "." + s.Substring(1, digs)
End Function
REM custom formatting
Function Joined(x() As BI) As String
Dim wids() = {1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
Dim res = ""
For i = 0 To x.Length - 1
res += String.Format("{0," + (-wids(i)).ToString + "} ", x(i))
Next
Return res
End Function
Sub Main()
REM calculates and checks each "metal"
Console.WriteLine("Metal B Sq.Rt Iters /---- 32 decimal place value ----\\ Matches Sq.Rt Calc")
Dim t = ""
Dim n As BI
Dim nm1 As BI
Dim k As Integer
Dim j As Integer
For b = 0 To 9
Dim lst(14) As BI
lst(0) = 1
lst(1) = 1
For i = 2 To 14
lst(i) = b * lst(i - 1) + lst(i - 2)
Next
REM since all the iterations (except Pt) are > 15, continue iterating from the end of the list of 15
n = lst(14)
nm1 = lst(13)
k = 0
j = 13
While k = 0
Dim lt = t
t = DivIt(n, nm1, 32)
If lt = t Then
k = If(b = 0, 1, j)
End If
Dim onn = n
n = b * n + nm1
nm1 = onn
j += 1
End While
Console.WriteLine("{0,4} {1} {2,2} {3, 2} {4} {5}" + vbNewLine + "{6,19} {7}", "Pt Au Ag CuSn Cu Ni Al Fe Sn Pb".Split(" ")(b), b, b * b + 4, k, t, t = DoOne(b, 32), "", Joined(lst))
Next
REM now calculate and check big one
n = 1
nm1 = 1
k = 0
j = 1
While k = 0
Dim lt = t
t = DivIt(n, nm1, 256)
If lt = t Then
k = j
End If
Dim onn = n
n += nm1
nm1 = onn
j += 1
End While
Console.WriteLine()
Console.WriteLine("Au to 256 digits:")
Console.WriteLine(t)
Console.WriteLine("Iteration count: {0} Matched Sq.Rt Calc: {1}", k, t = DoOne(1, 256))
End Sub
End Module

50
Task/Metallic-ratios/Wren/metallic-ratios.wren Normal file
View file

@ -0,0 +1,50 @@
import "/big" for BigInt, BigRat
import "/fmt" for Fmt
var names = ["Platinum", "Golden", "Silver", "Bronze", "Copper","Nickel", "Aluminium", "Iron", "Tin", "Lead"]
var lucas = Fn.new { |b|
Fmt.print("Lucas sequence for $s ratio, where b = $d:", names[b], b)
System.write("First 15 elements: ")
var x0 = 1
var x1 = 1
Fmt.write("$d, $d", x0, x1)
for (i in 1..13) {
var x2 = b*x1 + x0
Fmt.write(", $d", x2)
x0 = x1
x1 = x2
}
System.print()
}
var metallic = Fn.new { |b, dp|
var x0 = BigInt.one
var x1 = BigInt.one
var x2 = BigInt.zero
var bb = BigInt.new(b)
var ratio = BigRat.new(BigInt.one, BigInt.one)
var iters = 0
var prev = ratio.toDecimal(dp)
while (true) {
iters = iters + 1
x2 = bb*x1 + x0
ratio = BigRat.new(x2, x1)
var curr = ratio.toDecimal(dp)
if (prev == curr) {
var plural = (iters == 1) ? " " : "s"
Fmt.print("Value to $d dp after $2d iteration$s: $s\n", dp, iters, plural, curr)
return
}
prev = curr
x0 = x1
x1 = x2
}
}
for (b in 0..9) {
lucas.call(b)
metallic.call(b, 32)
}
System.print("Golden ratio, where b = 1:")
metallic.call(1, 256)

22
Task/Metallic-ratios/Zkl/metallic-ratios-1.zkl Normal file
View file

@ -0,0 +1,22 @@
var [const] BI=Import("zklBigNum"); // libGMP
fcn lucasSeq(b){
Walker.zero().tweak('wrap(xs){
xm2,xm1 := xs; // x[n-2], x[n-1]
xn:=xm1*b + xm2;
xs.append(xn).del(0);
xn
}.fp(L(BI(1),BI(1)))).push(1,1) // xn can get big so use BigInts
}
fcn metallicRatio(lucasSeq,digits=32,roundup=True){ #-->(String,num iterations)
bige:=BI("1e"+(digits+1)); # x[n-1]*bige*b / x[n-2] to get our digits from Ints
a,b,mr := lucasSeq.next(), lucasSeq.next(), (bige*b).div(a);
do(20_000){ // limit iterations
c,mr2 := lucasSeq.next(), (bige*c).div(b);
if(mr==mr2){
mr=mr2.add(5*roundup).div(10).toString();
return(String(mr[0],".",mr.del(0)),
lucasSeq.idx); // idx ignores push(), ie first 2 terms
}
b,mr = c,mr2;
}
}

7
Task/Metallic-ratios/Zkl/metallic-ratios-2.zkl Normal file
View file

@ -0,0 +1,7 @@
metals:="Platinum Golden Silver Bronze Copper Nickel Aluminum Iron Tin Lead";
foreach metal in (metals.split(" ")){ n:=__metalWalker.idx;
println("\nLucas sequence for %s ratio; where b = %d:".fmt(metal,n));
println("First 15 elements: ",lucasSeq(n).walk(15).concat(" "));
mr,i := metallicRatio(lucasSeq(n));
println("Approximated value: %s - Reached after ~%d iterations.".fmt(mr,i));
}

3
Task/Metallic-ratios/Zkl/metallic-ratios-3.zkl Normal file
View file

@ -0,0 +1,3 @@
println("Golden ratio (B==1) to 256 digits:");
mr,i := metallicRatio(lucasSeq(1),256);
println("Approximated value: %s\nReached after ~%d iterations.".fmt(mr,i));