Metallic ratios

From Rosetta Code
Task
Metallic ratios
You are encouraged to solve this task according to the task description, using any language you may know.

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:

         x2 - bx - 1 = 0 

where the integer b determines which specific one it is.

Using the quadratic equation:

         ( -b ± √(b2 - 4ac) ) / 2a = x 

Substitute in (from the top equation) 1 for a, -1 for c, and recognising that -b is negated we get:

         ( b ± √(b2 + 4) ) ) / 2 = x 

We only want the real root:

         ( b + √(b2 + 4) ) ) / 2 = x 

When we set b to 1, we get an irrational number: the Golden ratio.

         ( 1 + √(12 + 4) ) / 2  =  (1 + √5) / 2 = ~1.618033989... 

With b set to 2, we get a different irrational number: the Silver ratio.

         ( 2 + √(22 + 4) ) / 2  =  (2 + √8) / 2 = ~2.414213562... 

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:

         [b;b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b...] 


So, The first ten Metallic ratios are:

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


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:

   xn = P * xn-1 - Q * xn-2

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:

   xn = b * xn-1 + xn-2

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

   xn = xn-1 + xn-2
   1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...

more commonly known as the Fibonacci sequence.

When b = 2:

   xn = 2 * xn-1 + xn-2
   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 nth. 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

C#

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.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)); }
}
Output:
Metal B Sq.Rt Iters /---- 32 decimal place value ----\  Matches Sq.Rt Calc
  Pt  0    4     1  1.00000000000000000000000000000000  True
                    1 1 1  1  1   1    1     1      1       1        1         1          1           1            1             
  Au  1    5    78  1.61803398874989484820458683436564  True
                    1 1 2  3  5   8    13    21     34      55       89        144        233         377          610           
  Ag  2    8    44  2.41421356237309504880168872420970  True
                    1 1 3  7  17  41   99    239    577     1393     3363      8119       19601       47321        114243        
CuSn  3   13    34  3.30277563773199464655961063373525  True
                    1 1 4  13 43  142  469   1549   5116    16897    55807     184318     608761      2010601      6640564       
  Cu  4   20    28  4.23606797749978969640917366873128  True
                    1 1 5  21 89  377  1597  6765   28657   121393   514229    2178309    9227465     39088169     165580141     
  Ni  5   29    25  5.19258240356725201562535524577016  True
                    1 1 6  31 161 836  4341  22541  117046  607771   3155901   16387276   85092281    441848681    2294335686    
  Al  6   40    23  6.16227766016837933199889354443272  True
                    1 1 7  43 265 1633 10063 62011  382129  2354785  14510839  89419819   551029753   3395598337   20924619775   
  Fe  7   53    22  7.14005494464025913554865124576352  True
                    1 1 8  57 407 2906 20749 148149 1057792 7552693  53926643  385039194  2749201001  19629446201  140155324408  
  Sn  8   68    20  8.12310562561766054982140985597408  True
                    1 1 9  73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001  741780739449  
  Pb  9   85    20  9.10977222864644365500113714088140  True
                    1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226 

Au to 256 digits:
1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144
Iteration count: 616  Matched Sq.Rt Calc: True
Note: All the metals (except bronze) in this task are elements, so those symbols are used. Bronze is usually approx. 88% Cu and 12 % Sn, and so it is labeled CuSn here.

C++

Translation of: Go
Works with: C++11
Library: Boost
#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;
}
Output:
Lucas sequence for Platinum ratio, where b = 0:
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Value after 1 iteration: 1

Lucas sequence for Golden ratio, where b = 1:
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
Value after 78 iterations: 1.61803398874989484820458683436564

Lucas sequence for Silver ratio, where b = 2:
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243
Value after 44 iterations: 2.4142135623730950488016887242097

Lucas sequence for Bronze ratio, where b = 3:
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564
Value after 34 iterations: 3.30277563773199464655961063373525

Lucas sequence for Copper ratio, where b = 4:
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141
Value after 28 iterations: 4.23606797749978969640917366873128

Lucas sequence for Nickel ratio, where b = 5:
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686
Value after 25 iterations: 5.19258240356725201562535524577016

Lucas sequence for Aluminium ratio, where b = 6:
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775
Value after 23 iterations: 6.16227766016837933199889354443272

Lucas sequence for Iron ratio, where b = 7:
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408
Value after 22 iterations: 7.14005494464025913554865124576352

Lucas sequence for Tin ratio, where b = 8:
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449
Value after 20 iterations: 8.12310562561766054982140985597408

Lucas sequence for Lead ratio, where b = 9:
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226
Value after 20 iterations: 9.1097722286464436550011371408814

Golden ratio, where b = 1:
Value after 615 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

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     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
Output:
First 15 elements when P = 0 -> 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
32 decimal places required 1 iterations -> 1.00000000000000000000000000000000

First 15 elements when P = 1 -> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
32 decimal places required 79 iterations -> 1.61803398874989484820458683436563

First 15 elements when P = 2 -> 1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243
32 decimal places required 45 iterations -> 2.41421356237309504880168872420969

First 15 elements when P = 3 -> 1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564
32 decimal places required 33 iterations -> 3.30277563773199464655961063373524

First 15 elements when P = 4 -> 1 1 5 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141
32 decimal places required 28 iterations -> 4.23606797749978969640917366873127

First 15 elements when P = 5 -> 1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686
32 decimal places required 25 iterations -> 5.19258240356725201562535524577016

First 15 elements when P = 6 -> 1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775
32 decimal places required 23 iterations -> 6.16227766016837933199889354443271

First 15 elements when P = 7 -> 1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408
32 decimal places required 21 iterations -> 7.14005494464025913554865124576351

First 15 elements when P = 8 -> 1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449
32 decimal places required 20 iterations -> 8.12310562561766054982140985597407

First 15 elements when P = 9 -> 1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226
32 decimal places required 19 iterations -> 9.10977222864644365500113714088139

First 15 elements when P = 1 -> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 
256 decimal places required 614 iterations -> 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

Factor

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
Output:
Lucas sequence for Platinum ratio where b = 0:
First 15 elements: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
Approximated value: 1.00000000000000000000000000000000 - reached after  1  iteration(s)

Lucas sequence for Golden ratio where b = 1:
First 15 elements: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 
Approximated value: 1.61803398874989484820458683436563 - reached after  78  iteration(s)

Lucas sequence for Silver ratio where b = 2:
First 15 elements: 1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243 
Approximated value: 2.41421356237309504880168872420969 - reached after  44  iteration(s)

Lucas sequence for Bronze ratio where b = 3:
First 15 elements: 1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564 
Approximated value: 3.30277563773199464655961063373524 - reached after  32  iteration(s)

Lucas sequence for Copper ratio where b = 4:
First 15 elements: 1 1 5 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141 
Approximated value: 4.23606797749978969640917366873127 - reached after  27  iteration(s)

Lucas sequence for Nickel ratio where b = 5:
First 15 elements: 1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686 
Approximated value: 5.19258240356725201562535524577016 - reached after  24  iteration(s)

Lucas sequence for Aluminum ratio where b = 6:
First 15 elements: 1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775 
Approximated value: 6.16227766016837933199889354443271 - reached after  22  iteration(s)

Lucas sequence for Iron ratio where b = 7:
First 15 elements: 1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408 
Approximated value: 7.14005494464025913554865124576351 - reached after  20  iteration(s)

Lucas sequence for Tin ratio where b = 8:
First 15 elements: 1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449 
Approximated value: 8.12310562561766054982140985597407 - reached after  19  iteration(s)

Lucas sequence for Lead ratio where b = 9:
First 15 elements: 1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226 
Approximated value: 9.10977222864644365500113714088139 - reached after  18  iteration(s)

Go

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)
}
Output:
Lucas sequence for Platinum ratio, where b = 0:
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Value to 32 dp after  1 iteration : 1.00000000000000000000000000000000

Lucas sequence for Golden ratio, where b = 1:
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
Value to 32 dp after 78 iterations: 1.61803398874989484820458683436564

Lucas sequence for Silver ratio, where b = 2:
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243
Value to 32 dp after 44 iterations: 2.41421356237309504880168872420970

Lucas sequence for Bronze ratio, where b = 3:
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564
Value to 32 dp after 34 iterations: 3.30277563773199464655961063373525

Lucas sequence for Copper ratio, where b = 4:
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141
Value to 32 dp after 28 iterations: 4.23606797749978969640917366873128

Lucas sequence for Nickel ratio, where b = 5:
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686
Value to 32 dp after 25 iterations: 5.19258240356725201562535524577016

Lucas sequence for Aluminium ratio, where b = 6:
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775
Value to 32 dp after 23 iterations: 6.16227766016837933199889354443272

Lucas sequence for Iron ratio, where b = 7:
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408
Value to 32 dp after 22 iterations: 7.14005494464025913554865124576352

Lucas sequence for Tin ratio, where b = 8:
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449
Value to 32 dp after 20 iterations: 8.12310562561766054982140985597408

Lucas sequence for Lead ratio, where b = 9:
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226
Value to 32 dp after 20 iterations: 9.10977222864644365500113714088140

Golden ratio, where b = 1:
Value to 256 dp after 615 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

Groovy

Translation of: Kotlin
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)
    }
}
Output:
Lucas sequence for Platinum ratio, where b = 0
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Value after 2 iterations: 1

Lucas sequence for Golden ratio, where b = 1
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377
Value after 78 iterations: 1.61803398874989484820458683436564

Lucas sequence for Silver ratio, where b = 2
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321
Value after 44 iterations: 2.41421356237309504880168872420970

Lucas sequence for Bronze ratio, where b = 3
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601
Value after 34 iterations: 3.30277563773199464655961063373525

Lucas sequence for Copper ratio, where b = 4
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169
Value after 28 iterations: 4.23606797749978969640917366873128

Lucas sequence for Nickel ratio, where b = 5
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681
Value after 25 iterations: 5.19258240356725201562535524577016

Lucas sequence for Aluminum ratio, where b = 6
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337
Value after 23 iterations: 6.16227766016837933199889354443272

Lucas sequence for Iron ratio, where b = 7
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201
Value after 22 iterations: 7.14005494464025913554865124576352

Lucas sequence for Tin ratio, where b = 8
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001
Value after 20 iterations: 8.12310562561766054982140985597408

Lucas sequence for Lead ratio, where b = 9
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049
Value after 20 iterations: 9.10977222864644365500113714088140

Golden ratio, where b = 1:
Value after 615 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

J

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

Java

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;
    }
    
}
Output:
Lucas sequence for Platinum ratio, where b = 0:
First 15 elements: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Value to 32 decimal places after 1 iterations : 1

Lucas sequence for Golden ratio, where b = 1:
First 15 elements: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
Value to 32 decimal places after 78 iterations : 1.61803398874989484820458683436564

Lucas sequence for Silver ratio, where b = 2:
First 15 elements: [1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243]
Value to 32 decimal places after 44 iterations : 2.41421356237309504880168872420970

Lucas sequence for Bronze ratio, where b = 3:
First 15 elements: [1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564]
Value to 32 decimal places after 34 iterations : 3.30277563773199464655961063373525

Lucas sequence for Copper ratio, where b = 4:
First 15 elements: [1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141]
Value to 32 decimal places after 28 iterations : 4.23606797749978969640917366873128

Lucas sequence for Nickel ratio, where b = 5:
First 15 elements: [1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686]
Value to 32 decimal places after 25 iterations : 5.19258240356725201562535524577016

Lucas sequence for Aluminum ratio, where b = 6:
First 15 elements: [1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775]
Value to 32 decimal places after 23 iterations : 6.16227766016837933199889354443272

Lucas sequence for Iron ratio, where b = 7:
First 15 elements: [1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408]
Value to 32 decimal places after 22 iterations : 7.14005494464025913554865124576352

Lucas sequence for Tin ratio, where b = 8:
First 15 elements: [1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449]
Value to 32 decimal places after 20 iterations : 8.12310562561766054982140985597408

Lucas sequence for Lead ratio, where b = 9:
First 15 elements: [1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226]
Value to 32 decimal places after 20 iterations : 9.10977222864644365500113714088140

Golden ratio, where b = 1:
Value to 256 decimal places after 615 iterations : 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

jq

Works with gojq, the Go implementation of jq

Translation of: Wren

The "Rational" module used here is available at Arithmetic/Rational#jq. Note that in the version of this module used to produce the output shown below, the function `r_to_decimal/1` does not perform rounding of the last digit, and so these results should be correspondingly interpreted.

The accuracy of the following program in some cases depends on unbounded-precision integer arithmetic, which the C implementation of jq does not support.

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)

Invocation: gojq -nrcf metallic-ratios.jq

Output:
Lucas sequence for Platinum ratio, where b = 0:
First 15 elements: 
[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
Value to 32 dp after 1 iteration : 1

Lucas sequence for Golden ratio, where b = 1:
First 15 elements: 
[1,1,2,3,5,8,13,21,34,55,89,144,233,377,610]
Value to 32 dp after 79 iterations: 1.61803398874989484820458683436563

Lucas sequence for Silver ratio, where b = 2:
First 15 elements: 
[1,1,3,7,17,41,99,239,577,1393,3363,8119,19601,47321,114243]
Value to 32 dp after 45 iterations: 2.41421356237309504880168872420969

Lucas sequence for Bronze ratio, where b = 3:
First 15 elements: 
[1,1,4,13,43,142,469,1549,5116,16897,55807,184318,608761,2010601,6640564]
Value to 32 dp after 33 iterations: 3.30277563773199464655961063373524

Lucas sequence for Copper ratio, where b = 4:
First 15 elements: 
[1,1,5,21,89,377,1597,6765,28657,121393,514229,2178309,9227465,39088169,165580141]
Value to 32 dp after 28 iterations: 4.23606797749978969640917366873127

Lucas sequence for Nickel ratio, where b = 5:
First 15 elements: 
[1,1,6,31,161,836,4341,22541,117046,607771,3155901,16387276,85092281,441848681,2294335686]
Value to 32 dp after 25 iterations: 5.19258240356725201562535524577016

Lucas sequence for Aluminium ratio, where b = 6:
First 15 elements: 
[1,1,7,43,265,1633,10063,62011,382129,2354785,14510839,89419819,551029753,3395598337,20924619775]
Value to 32 dp after 23 iterations: 6.16227766016837933199889354443271

Lucas sequence for Iron ratio, where b = 7:
First 15 elements: 
[1,1,8,57,407,2906,20749,148149,1057792,7552693,53926643,385039194,2749201001,19629446201,140155324408]
Value to 32 dp after 21 iterations: 7.14005494464025913554865124576351

Lucas sequence for Tin ratio, where b = 8:
First 15 elements: 
[1,1,9,73,593,4817,39129,317849,2581921,20973217,170367657,1383914473,11241683441,91317382001,741780739449]
Value to 32 dp after 20 iterations: 8.12310562561766054982140985597407

Lucas sequence for Lead ratio, where b = 9:
First 15 elements: 
[1,1,10,91,829,7552,68797,626725,5709322,52010623,473804929,4316254984,39320099785,358197153049,3263094477226]
Value to 32 dp after 19 iterations: 9.10977222864644365500113714088139

Golden ratio, where b = 1:
Value to 256 dp after 614 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

Julia

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)
Output:
The first 15 elements of the Lucas sequence named Platinum and b of 0 are:
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
After 2 iterations, the value of 1.00000000000000000000000000000000 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Golden and b of 1 are:
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, ...
After 79 iterations, the value of 1.61803398874989484820458683436564 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Silver and b of 2 are:
1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243, ...
After 45 iterations, the value of 2.41421356237309504880168872420970 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Bronze and b of 3 are:
1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564, ...
After 34 iterations, the value of 3.30277563773199464655961063373525 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Copper and b of 4 are:
1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141, ...
After 29 iterations, the value of 4.23606797749978969640917366873128 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Nickel and b of 5 are:
1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686, ...
After 26 iterations, the value of 5.19258240356725201562535524577016 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Aluminium and b of 6 are:
1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775, ...
After 24 iterations, the value of 6.16227766016837933199889354443272 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Iron and b of 7 are:
1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408, ...
After 22 iterations, the value of 7.14005494464025913554865124576352 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Tin and b of 8 are:
1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449, ...
After 21 iterations, the value of 8.12310562561766054982140985597408 is stable to 32 decimal places.

The first 15 elements of the Lucas sequence named Lead and b of 9 are:
1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226, ...
After 20 iterations, the value of 9.10977222864644365500113714088140 is stable to 32 decimal places.

Golden ratio to 256 decimal places:
After 615 iterations, the value of 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144 is stable to 256 decimal places.

Kotlin

Translation of: Go
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)
}
Output:
Lucas sequence for Platinum ratio, where b = 0:
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Value after 1 iteration: 1.00000000000000000000000000000000

Lucas sequence for Golden ratio, where b = 1:
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
Value after 78 iterations: 1.61803398874989484820458683436564

Lucas sequence for Silver ratio, where b = 2:
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243
Value after 44 iterations: 2.41421356237309504880168872420970

Lucas sequence for Bronze ratio, where b = 3:
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564
Value after 34 iterations: 3.30277563773199464655961063373525

Lucas sequence for Copper ratio, where b = 4:
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141
Value after 28 iterations: 4.23606797749978969640917366873128

Lucas sequence for Nickel ratio, where b = 5:
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686
Value after 25 iterations: 5.19258240356725201562535524577016

Lucas sequence for Aluminium ratio, where b = 6:
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775
Value after 23 iterations: 6.16227766016837933199889354443272

Lucas sequence for Iron ratio, where b = 7:
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408
Value after 22 iterations: 7.14005494464025913554865124576352

Lucas sequence for Tin ratio, where b = 8:
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449
Value after 20 iterations: 8.12310562561766054982140985597408

Lucas sequence for Lead ratio, where b = 9:
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226
Value after 20 iterations: 9.10977222864644365500113714088140

Golden ration, where b = 1:
Value after 615 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

Mathematica/Wolfram Language

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]
Output:
b=0
b=0 first 15={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
b=0 ratio=1.00000000000000000000000000000000
b=0 Number of steps=16
b=1
b=1 first 15={1,1,2,3,5,8,13,21,34,55,89,144,233,377,610}
b=1 ratio=1.61803398874989484820458683436564
b=1 Number of steps=78
b=2
b=2 first 15={1,1,3,7,17,41,99,239,577,1393,3363,8119,19601,47321,114243}
b=2 ratio=2.41421356237309504880168872420970
b=2 Number of steps=44
b=3
b=3 first 15={1,1,4,13,43,142,469,1549,5116,16897,55807,184318,608761,2010601,6640564}
b=3 ratio=3.30277563773199464655961063373525
b=3 Number of steps=33
b=4
b=4 first 15={1,1,5,21,89,377,1597,6765,28657,121393,514229,2178309,9227465,39088169,165580141}
b=4 ratio=4.236067977499789696409173668731276
b=4 Number of steps=28
b=5
b=5 first 15={1,1,6,31,161,836,4341,22541,117046,607771,3155901,16387276,85092281,441848681,2294335686}
b=5 ratio=5.19258240356725201562535524577016
b=5 Number of steps=25
b=6
b=6 first 15={1,1,7,43,265,1633,10063,62011,382129,2354785,14510839,89419819,551029753,3395598337,20924619775}
b=6 ratio=6.162277660168379331998893544432719
b=6 Number of steps=23
b=7
b=7 first 15={1,1,8,57,407,2906,20749,148149,1057792,7552693,53926643,385039194,2749201001,19629446201,140155324408}
b=7 ratio=7.14005494464025913554865124576352
b=7 Number of steps=21
b=8
b=8 first 15={1,1,9,73,593,4817,39129,317849,2581921,20973217,170367657,1383914473,11241683441,91317382001,741780739449}
b=8 ratio=8.123105625617660549821409855974077
b=8 Number of steps=20
b=9
b=9 first 15={1,1,10,91,829,7552,68797,626725,5709322,52010623,473804929,4316254984,39320099785,358197153049,3263094477226}
b=9 ratio=9.10977222864644365500113714088140
b=9 Number of steps=19
614
1.618033988749894848204586834365638117720309179805762862135448622705260462818902449707207204189391137484754088075386891752126633862223536931793180060766726354433389086595939582905638322661319928290267880675208766892501711696207032221043216269548626296313614

Nim

Library: bignum
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)
Output:
“Lucas” sequence for platinum ratio where b = 0:
First 15 elements: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Value to 32 decimal places after 1 iteration: 1.00000000000000000000000000000000

“Lucas” sequence for golden ratio where b = 1:
First 15 elements: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
Value to 32 decimal places after 79 iterations: 1.61803398874989484820458683436563

“Lucas” sequence for silver ratio where b = 2:
First 15 elements: 1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243
Value to 32 decimal places after 45 iterations: 2.41421356237309504880168872420969

“Lucas” sequence for bronze ratio where b = 3:
First 15 elements: 1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564
Value to 32 decimal places after 33 iterations: 3.30277563773199464655961063373524

“Lucas” sequence for copper ratio where b = 4:
First 15 elements: 1 1 5 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141
Value to 32 decimal places after 28 iterations: 4.23606797749978969640917366873127

“Lucas” sequence for nickel ratio where b = 5:
First 15 elements: 1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686
Value to 32 decimal places after 25 iterations: 5.19258240356725201562535524577016

“Lucas” sequence for aluminium ratio where b = 6:
First 15 elements: 1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775
Value to 32 decimal places after 23 iterations: 6.16227766016837933199889354443271

“Lucas” sequence for iron ratio where b = 7:
First 15 elements: 1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408
Value to 32 decimal places after 21 iterations: 7.14005494464025913554865124576351

“Lucas” sequence for tin ratio where b = 8:
First 15 elements: 1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449
Value to 32 decimal places after 20 iterations: 8.12310562561766054982140985597407

“Lucas” sequence for lead ratio where b = 9:
First 15 elements: 1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226
Value to 32 decimal places after 19 iterations: 9.10977222864644365500113714088139

Golden ratio where b = 1:
Value to 256 decimal places after 614 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

Perl

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);
Output:
'Lucas' sequence for Platinum ratio, where b = 0:
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Approximated value 1 reached after 1 iterations

'Lucas' sequence for Golden ratio, where b = 1:
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
Approximated value 1.61803398874989484820458683436564 reached after 78 iterations

'Lucas' sequence for Silver ratio, where b = 2:
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243
Approximated value 2.4142135623730950488016887242097 reached after 44 iterations

'Lucas' sequence for Bronze ratio, where b = 3:
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564
Approximated value 3.30277563773199464655961063373525 reached after 34 iterations

'Lucas' sequence for Copper ratio, where b = 4:
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141
Approximated value 4.23606797749978969640917366873128 reached after 28 iterations

'Lucas' sequence for Nickel ratio, where b = 5:
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686
Approximated value 5.19258240356725201562535524577016 reached after 25 iterations

'Lucas' sequence for Aluminum ratio, where b = 6:
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775
Approximated value 6.16227766016837933199889354443272 reached after 23 iterations

'Lucas' sequence for Iron ratio, where b = 7:
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408
Approximated value 7.14005494464025913554865124576352 reached after 22 iterations

'Lucas' sequence for Tin ratio, where b = 8:
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449
Approximated value 8.12310562561766054982140985597408 reached after 20 iterations

'Lucas' sequence for Lead ratio, where b = 9:
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226
Approximated value 9.1097722286464436550011371408814 reached after 20 iterations

Golden ratio to 256 decimal places 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144 reached after 615 iterations

Phix

Translation of: Go
Library: Phix/mpfr
with javascript_semantics
include mpfr.e
 
constant names = {"Platinum", "Golden", "Silver", "Bronze", "Copper",
                  "Nickel", "Aluminium", "Iron", "Tin", "Lead"}
 
procedure lucas(integer b)
    printf(1,"Lucas sequence for %s ratio, where b = %d:\n", {names[b+1], b})
    atom x0 = 1, x1 = 1, x2
    printf(1,"First 15 elements: %d, %d", {x0, x1})
    for i=1 to 13 do
        x2 = b*x1 + x0
        printf(1,", %d", x2)
        x0 = x1
        x1 = x2
    end for
    printf(1,"\n")
end procedure
 
procedure metallic(integer b, dp)
    mpz {x0, x1, x2, bb} = mpz_inits(4,{1,1,0,b})
    mpfr ratio = mpfr_init(1,-(dp+2))
    integer iterations = 0
    string prev = mpfr_get_fixed(ratio,dp)
    while true do
        iterations += 1
        mpz_mul(x2,bb,x1)
        mpz_add(x2,x2,x0)
        mpfr_set_z(ratio,x2)
        mpfr_div_z(ratio,ratio,x1)
        string curr = mpfr_get_fixed(ratio,dp)
        if prev == curr then
            string plural = iff(iterations=1?"":"s")
            curr = shorten(curr)
            printf(1,"Value to %d dp after %2d iteration%s: %s\n\n", {dp, iterations, plural, curr})
            exit
        end if
        prev = curr
        mpz_set(x0,x1)
        mpz_set(x1,x2)
    end while
end procedure
 
procedure main()
    for b=0 to 9 do
        lucas(b)
        metallic(b, 32)
    end for
    printf(1,"Golden ratio, where b = 1:\n")
    metallic(1, 256)
end procedure
main()
Output:

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

Lucas sequence for Platinum ratio, where b = 0:
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Value to 32 dp after  1 iteration: 1.00000000000000000000000000000000

Lucas sequence for Golden ratio, where b = 1:
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
Value to 32 dp after 78 iterations: 1.61803398874989484820458683436564

Lucas sequence for Silver ratio, where b = 2:
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243
Value to 32 dp after 44 iterations: 2.41421356237309504880168872420970

Lucas sequence for Bronze ratio, where b = 3:
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564
Value to 32 dp after 34 iterations: 3.30277563773199464655961063373525

Lucas sequence for Copper ratio, where b = 4:
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141
Value to 32 dp after 28 iterations: 4.23606797749978969640917366873128

Lucas sequence for Nickel ratio, where b = 5:
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686
Value to 32 dp after 25 iterations: 5.19258240356725201562535524577016

Lucas sequence for Aluminium ratio, where b = 6:
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775
Value to 32 dp after 23 iterations: 6.16227766016837933199889354443272

Lucas sequence for Iron ratio, where b = 7:
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408
Value to 32 dp after 22 iterations: 7.14005494464025913554865124576352

Lucas sequence for Tin ratio, where b = 8:
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449
Value to 32 dp after 20 iterations: 8.12310562561766054982140985597408

Lucas sequence for Lead ratio, where b = 9:
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226
Value to 32 dp after 20 iterations: 9.10977222864644365500113714088140

Golden ratio, where b = 1:
Value to 256 dp after 615 iterations: 1.61803398874989484...2695486262963136144 (258 digits)

Python

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)
Output:
b = 0: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
after 1 iterations:
        1

b = 1: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
after 77 iterations:
        1.6180339887498948482045868343656

b = 2: [1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243]
after 43 iterations:
        2.4142135623730950488016887242097

b = 3: [1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564]
after 33 iterations:
        3.3027756377319946465596106337352

b = 1 with 256 digits:
after 613 iterations:
        1.618033988749894848204586834365638117720309179805762862135448622705260462818902449707207204189391137484754088075386891752126633862223536931793180060766726354433389086595939582905638322661319928290267880675208766892501711696207032221043216269548626296313614

Quackery

  [ $ "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 ]
Output:
Platinum
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
1 1

Golden
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 
78 1.61803398874989484820458683436564

Silver
1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243 
44 2.4142135623730950488016887242097

Bronze
1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564 
33 3.30277563773199464655961063373524

Copper
1 1 5 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141 
28 4.23606797749978969640917366873128

Nickel
1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686 
25 5.19258240356725201562535524577016

Aluminium
1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775 
23 6.16227766016837933199889354443272

Iron
1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408 
21 7.14005494464025913554865124576351

Tin
1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449 
20 8.12310562561766054982140985597408

Lead
1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226 
19 9.10977222864644365500113714088139

Raku

(formerly Perl 6)

Works with: Rakudo version 2019.07.1

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

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;
Output:
Lucas sequence for Platinum ratio; where b = 0:
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Approximated value: 1.00000000000000000000000000000000 Reached after 1 iterations: 1st/0th element.

Lucas sequence for Golden ratio; where b = 1:
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
Approximated value: 1.61803398874989484820458683436564 Reached after 78 iterations: 78th/77th element.

Lucas sequence for Silver ratio; where b = 2:
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243
Approximated value: 2.41421356237309504880168872420970 Reached after 44 iterations: 44th/43rd element.

Lucas sequence for Bronze ratio; where b = 3:
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564
Approximated value: 3.30277563773199464655961063373525 Reached after 34 iterations: 34th/33rd element.

Lucas sequence for Copper ratio; where b = 4:
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141
Approximated value: 4.23606797749978969640917366873128 Reached after 28 iterations: 28th/27th element.

Lucas sequence for Nickel ratio; where b = 5:
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686
Approximated value: 5.19258240356725201562535524577016 Reached after 25 iterations: 25th/24th element.

Lucas sequence for Aluminum ratio; where b = 6:
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775
Approximated value: 6.16227766016837933199889354443272 Reached after 23 iterations: 23rd/22nd element.

Lucas sequence for Iron ratio; where b = 7:
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408
Approximated value: 7.14005494464025913554865124576352 Reached after 22 iterations: 22nd/21st element.

Lucas sequence for Tin ratio; where b = 8:
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449
Approximated value: 8.12310562561766054982140985597408 Reached after 20 iterations: 20th/19th element.

Lucas sequence for Lead ratio; where b = 9:
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226
Approximated value: 9.10977222864644365500113714088140 Reached after 20 iterations: 20th/19th element.

Golden ratio to 256 decimal places:
Approximated value:
1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144
Reached after 615 iterations: 615th/614th element.

REXX

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

/*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. */
output   when using the default inputs:

Shown at three-quarter size.)

═════════════════════════ Lucas sequence for the platinum ratio,  where  B  is  0 ══════════════════════════
the first  15  elements are:
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
the exact value reached after 2  iterations with  32  decimal digits past the decimal point:
1

══════════════════════════ Lucas sequence for the golden ratio,  where  B  is  1 ═══════════════════════════
the first  15  elements are:
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
the approximate value reached after 78  iterations with  32  decimal digits past the decimal point:
1.61803398874989484820458683436564

══════════════════════════ Lucas sequence for the silver ratio,  where  B  is  2 ═══════════════════════════
the first  15  elements are:
1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243
the approximate value reached after 44  iterations with  32  decimal digits past the decimal point:
2.41421356237309504880168872420970

══════════════════════════ Lucas sequence for the bronze ratio,  where  B  is  3 ═══════════════════════════
the first  15  elements are:
1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564
the approximate value reached after 34  iterations with  32  decimal digits past the decimal point:
3.30277563773199464655961063373525

══════════════════════════ Lucas sequence for the copper ratio,  where  B  is  4 ═══════════════════════════
the first  15  elements are:
1 1 5 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141
the approximate value reached after 28  iterations with  32  decimal digits past the decimal point:
4.23606797749978969640917366873128

══════════════════════════ Lucas sequence for the nickel ratio,  where  B  is  5 ═══════════════════════════
the first  15  elements are:
1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686
the approximate value reached after 25  iterations with  32  decimal digits past the decimal point:
5.19258240356725201562535524577016

═════════════════════════ Lucas sequence for the aluminum ratio,  where  B  is  6 ══════════════════════════
the first  15  elements are:
1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775
the approximate value reached after 23  iterations with  32  decimal digits past the decimal point:
6.16227766016837933199889354443272

═══════════════════════════ Lucas sequence for the iron ratio,  where  B  is  7 ════════════════════════════
the first  15  elements are:
1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408
the approximate value reached after 22  iterations with  32  decimal digits past the decimal point:
7.14005494464025913554865124576352

════════════════════════════ Lucas sequence for the tin ratio,  where  B  is  8 ════════════════════════════
the first  15  elements are:
1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449
the approximate value reached after 20  iterations with  32  decimal digits past the decimal point:
8.12310562561766054982140985597408

═══════════════════════════ Lucas sequence for the lead ratio,  where  B  is  9 ════════════════════════════
the first  15  elements are:
1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226
the approximate value reached after 20  iterations with  32  decimal digits past the decimal point:
9.10977222864644365500113714088140
output   when using the inputs of:     0   1   1   256

(Shown at three-quarter size.)

══════════════════════════ Lucas sequence for the golden ratio,  where  B  is  1 ═══════════════════════════
the approximate value reached after  615  iterations with  256  decimal digits past the decimal point:
1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

RPL

Works with: HP version 49
« UNROT SWAP OVER IDIV2 SWAP "." + 4 ROLLD UNROT
  → b
  « 1 SWAP START
       10 * b IDIV2
       UNROT + SWAP
    NEXT DROP
» » 'LDIVN' STO     @ ( a b p → "float" ) with float = a/b with p decimal places

« 0 9 FOR b
     { "Pt" "Au" "Ag" "CuSn" "Cu" "Ni" "Al" "Fe" "Sn" "Pb" } b 1 + DUP SUB
     1 1 
     3 15 START DUP2 b * + NEXT 
     15 →LIST "seq" →TAG +
     0 1 1 "1.00000000000000000000000000000000"
     DO UNROT DUP b * ROT + 
        4 ROLL 1 + 4 ROLLD 
     UNTIL DUP2 SWAP 32 LDIVN 4 ROLL OVER == END 
     "ratio" →TAG UNROT DROP2 ROT SWAP +
     SWAP "iter" →TAG +
  NEXT
» 'TASK' STO
Output:
10: { "Pt" seq:{ 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 } ratio:"1.00000000000000000000000000000000" iter:1 } 
9: { "Au" seq:{ 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 } 
ratio:"1.61803398874989484820458683436563" iter:79 } 
8: { "Ag" seq:{ 1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243 } ratio:"2.41421356237309504880168872420969" iter:45 } 
7: { "CuSn" seq:{ 1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564 } ratio:"3.30277563773199464655961063373524" iter:33 } { "Cu" seq:{ 1 1 5 6: 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141 } ratio:"4.23606797749978969640917366873127" iter:28 }
5: { "Ni" seq:{ 1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686 } ratio:"5.19258240356725201562535524577016" iter:25 } 
4: { "Al" seq:{ 1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775 } ratio:"6.16227766016837933199889354443271" iter:23 } 
3: { "Fe" seq:{ 1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408 } ratio:"7.14005494464025913554865124576351" iter:21 } 
2: { "Sn" seq:{ 1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449 } ratio:"8.12310562561766054982140985597407" iter:20 } 
1: { "Pb" seq:{ 1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226 } ratio:"9.10977222864644365500113714088139" iter:19 }

Ruby

Works with: Ruby version 2.3
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')])
Output:
Lucas Sequences...
b  sequence
0  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
1  [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
2  [1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243]
3  [1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564]
4  [1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141]
5  [1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686]
6  [1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775]
7  [1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408]
8  [1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449]
9  [1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226]

Metallic Ratios to 32 places...
name      b   n  ratio
Platinum  0   1  1.0
Golden    1  78  1.61803398874989484820458683436564
Silver    2  44  2.4142135623730950488016887242097
Bronze    3  34  3.30277563773199464655961063373525
Copper    4  28  4.23606797749978969640917366873128
Nickel    5  25  5.19258240356725201562535524577016
Aluminum  6  23  6.16227766016837933199889354443272
Iron      7  22  7.14005494464025913554865124576352
Tin       8  20  8.12310562561766054982140985597408
Lead      9  20  9.1097722286464436550011371408814

Golden Ratio to 256 places...
name      b   n  ratio
Golden    1 615  1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

Sidef

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"
}
Output:
Lucas sequence U_n(1,-1) for Golden ratio
First 15 elements: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377
Approximated value: 1.61803398874989484820458683436564 reached after 79 iterations

Lucas sequence U_n(2,-1) for Silver ratio
First 15 elements: 0, 1, 2, 5, 12, 29, 70, 169, 408, 985, 2378, 5741, 13860, 33461, 80782
Approximated value: 2.4142135623730950488016887242097 reached after 45 iterations

Lucas sequence U_n(3,-1) for Bronze ratio
First 15 elements: 0, 1, 3, 10, 33, 109, 360, 1189, 3927, 12970, 42837, 141481, 467280, 1543321, 5097243
Approximated value: 3.30277563773199464655961063373525 reached after 33 iterations

Lucas sequence U_n(4,-1) for Copper ratio
First 15 elements: 0, 1, 4, 17, 72, 305, 1292, 5473, 23184, 98209, 416020, 1762289, 7465176, 31622993, 133957148
Approximated value: 4.23606797749978969640917366873128 reached after 28 iterations

Lucas sequence U_n(5,-1) for Nickel ratio
First 15 elements: 0, 1, 5, 26, 135, 701, 3640, 18901, 98145, 509626, 2646275, 13741001, 71351280, 370497401, 1923838285
Approximated value: 5.19258240356725201562535524577016 reached after 26 iterations

Lucas sequence U_n(6,-1) for Aluminum ratio
First 15 elements: 0, 1, 6, 37, 228, 1405, 8658, 53353, 328776, 2026009, 12484830, 76934989, 474094764, 2921503573, 18003116202
Approximated value: 6.16227766016837933199889354443272 reached after 23 iterations

Lucas sequence U_n(7,-1) for Iron ratio
First 15 elements: 0, 1, 7, 50, 357, 2549, 18200, 129949, 927843, 6624850, 47301793, 337737401, 2411463600, 17217982601, 122937341807
Approximated value: 7.14005494464025913554865124576352 reached after 21 iterations

Lucas sequence U_n(8,-1) for Tin ratio
First 15 elements: 0, 1, 8, 65, 528, 4289, 34840, 283009, 2298912, 18674305, 151693352, 1232221121, 10009462320, 81307919681, 660472819768
Approximated value: 8.12310562561766054982140985597408 reached after 20 iterations

Lucas sequence U_n(9,-1) for Lead ratio
First 15 elements: 0, 1, 9, 82, 747, 6805, 61992, 564733, 5144589, 46866034, 426938895, 3889316089, 35430783696, 322766369353, 2940328107873
Approximated value: 9.1097722286464436550011371408814 reached after 19 iterations

Golden ratio to 256 decimal places:
Approximated value: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144
Reached after 616 iterations

Visual Basic .NET

Translation of: C#
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
Output:
Metal B Sq.Rt Iters /---- 32 decimal place value ----\\  Matches Sq.Rt Calc
  Pt  0    4     1  1.00000000000000000000000000000000  True
                    1 1 1  1  1   1    1     1      1       1        1         1          1           1            1
  Au  1    5    78  1.61803398874989484820458683436564  True
                    1 1 2  3  5   8    13    21     34      55       89        144        233         377          610
  Ag  2    8    44  2.41421356237309504880168872420970  True
                    1 1 3  7  17  41   99    239    577     1393     3363      8119       19601       47321        114243
CuSn  3   13    34  3.30277563773199464655961063373525  True
                    1 1 4  13 43  142  469   1549   5116    16897    55807     184318     608761      2010601      6640564
  Cu  4   20    28  4.23606797749978969640917366873128  True
                    1 1 5  21 89  377  1597  6765   28657   121393   514229    2178309    9227465     39088169     165580141
  Ni  5   29    25  5.19258240356725201562535524577016  True
                    1 1 6  31 161 836  4341  22541  117046  607771   3155901   16387276   85092281    441848681    2294335686
  Al  6   40    23  6.16227766016837933199889354443272  True
                    1 1 7  43 265 1633 10063 62011  382129  2354785  14510839  89419819   551029753   3395598337   20924619775
  Fe  7   53    22  7.14005494464025913554865124576352  True
                    1 1 8  57 407 2906 20749 148149 1057792 7552693  53926643  385039194  2749201001  19629446201  140155324408
  Sn  8   68    20  8.12310562561766054982140985597408  True
                    1 1 9  73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001  741780739449
  Pb  9   85    20  9.10977222864644365500113714088140  True
                    1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226

Au to 256 digits:
1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144
Iteration count: 616  Matched Sq.Rt Calc: True

Wren

Translation of: Go
Library: Wren-big
Library: Wren-fmt
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)
Output:
Lucas sequence for Platinum ratio, where b = 0:
First 15 elements: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
Value to 32 dp after  1 iteration : 1

Lucas sequence for Golden ratio, where b = 1:
First 15 elements: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610
Value to 32 dp after 78 iterations: 1.61803398874989484820458683436564

Lucas sequence for Silver ratio, where b = 2:
First 15 elements: 1, 1, 3, 7, 17, 41, 99, 239, 577, 1393, 3363, 8119, 19601, 47321, 114243
Value to 32 dp after 44 iterations: 2.41421356237309504880168872420970

Lucas sequence for Bronze ratio, where b = 3:
First 15 elements: 1, 1, 4, 13, 43, 142, 469, 1549, 5116, 16897, 55807, 184318, 608761, 2010601, 6640564
Value to 32 dp after 34 iterations: 3.30277563773199464655961063373525

Lucas sequence for Copper ratio, where b = 4:
First 15 elements: 1, 1, 5, 21, 89, 377, 1597, 6765, 28657, 121393, 514229, 2178309, 9227465, 39088169, 165580141
Value to 32 dp after 28 iterations: 4.23606797749978969640917366873128

Lucas sequence for Nickel ratio, where b = 5:
First 15 elements: 1, 1, 6, 31, 161, 836, 4341, 22541, 117046, 607771, 3155901, 16387276, 85092281, 441848681, 2294335686
Value to 32 dp after 25 iterations: 5.19258240356725201562535524577016

Lucas sequence for Aluminium ratio, where b = 6:
First 15 elements: 1, 1, 7, 43, 265, 1633, 10063, 62011, 382129, 2354785, 14510839, 89419819, 551029753, 3395598337, 20924619775
Value to 32 dp after 23 iterations: 6.16227766016837933199889354443272

Lucas sequence for Iron ratio, where b = 7:
First 15 elements: 1, 1, 8, 57, 407, 2906, 20749, 148149, 1057792, 7552693, 53926643, 385039194, 2749201001, 19629446201, 140155324408
Value to 32 dp after 22 iterations: 7.14005494464025913554865124576352

Lucas sequence for Tin ratio, where b = 8:
First 15 elements: 1, 1, 9, 73, 593, 4817, 39129, 317849, 2581921, 20973217, 170367657, 1383914473, 11241683441, 91317382001, 741780739449
Value to 32 dp after 20 iterations: 8.12310562561766054982140985597408

Lucas sequence for Lead ratio, where b = 9:
First 15 elements: 1, 1, 10, 91, 829, 7552, 68797, 626725, 5709322, 52010623, 473804929, 4316254984, 39320099785, 358197153049, 3263094477226
Value to 32 dp after 20 iterations: 9.10977222864644365500113714088140

Golden ratio, where b = 1:
Value to 256 dp after 615 iterations: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144

zkl

Library: GMP
GNU Multiple Precision Arithmetic Library
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;
   }
}
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));
}
Output:
Lucas sequence for Platinum ratio; where b = 0:
First 15 elements: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Approximated value: 1.00000000000000000000000000000000 - Reached after ~0 iterations.

Lucas sequence for Golden ratio; where b = 1:
First 15 elements: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
Approximated value: 1.61803398874989484820458683436564 - Reached after ~81 iterations.

Lucas sequence for Silver ratio; where b = 2:
First 15 elements: 1 1 3 7 17 41 99 239 577 1393 3363 8119 19601 47321 114243
Approximated value: 2.41421356237309504880168872420970 - Reached after ~45 iterations.

Lucas sequence for Bronze ratio; where b = 3:
First 15 elements: 1 1 4 13 43 142 469 1549 5116 16897 55807 184318 608761 2010601 6640564
Approximated value: 3.30277563773199464655961063373525 - Reached after ~34 iterations.

Lucas sequence for Copper ratio; where b = 4:
First 15 elements: 1 1 5 21 89 377 1597 6765 28657 121393 514229 2178309 9227465 39088169 165580141
Approximated value: 4.23606797749978969640917366873128 - Reached after ~28 iterations.

Lucas sequence for Nickel ratio; where b = 5:
First 15 elements: 1 1 6 31 161 836 4341 22541 117046 607771 3155901 16387276 85092281 441848681 2294335686
Approximated value: 5.19258240356725201562535524577016 - Reached after ~25 iterations.

Lucas sequence for Aluminum ratio; where b = 6:
First 15 elements: 1 1 7 43 265 1633 10063 62011 382129 2354785 14510839 89419819 551029753 3395598337 20924619775
Approximated value: 6.16227766016837933199889354443272 - Reached after ~22 iterations.

Lucas sequence for Iron ratio; where b = 7:
First 15 elements: 1 1 8 57 407 2906 20749 148149 1057792 7552693 53926643 385039194 2749201001 19629446201 140155324408
Approximated value: 7.14005494464025913554865124576352 - Reached after ~21 iterations.

Lucas sequence for Tin ratio; where b = 8:
First 15 elements: 1 1 9 73 593 4817 39129 317849 2581921 20973217 170367657 1383914473 11241683441 91317382001 741780739449
Approximated value: 8.12310562561766054982140985597408 - Reached after ~20 iterations.

Lucas sequence for Lead ratio; where b = 9:
First 15 elements: 1 1 10 91 829 7552 68797 626725 5709322 52010623 473804929 4316254984 39320099785 358197153049 3263094477226
Approximated value: 9.10977222864644365500113714088140 - Reached after ~19 iterations.
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));
Output:
Golden ratio (b==1) to 256 digits:
Approximated value: 1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752087668925017116962070322210432162695486262963136144
Reached after ~616 iterations.