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

Data commit

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

2
Task/Pell-numbers/00-META.yaml Normal file
View file

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

95
Task/Pell-numbers/00-TASK.txt Normal file
View file

@ -0,0 +1,95 @@
'''Pell numbers''' are an infinite sequence of integers that comprise the denominators of the closest rational approximations to the square root of 2 but have many other interesting uses and relationships.
The numerators of each term of rational approximations to the square root of 2 may ''also'' be derived from '''Pell numbers''', or may be found by taking half of each term of the related sequence: '''Pell-Lucas''' or '''Pell-companion numbers'''.
The '''Pell numbers''': '''0, 1, 2, 5, 12, 29, 70, etc.''', are defined by the recurrence relation:
<span style="font-size:125%;font-weight:bold;">
P<sub>0</sub> = 0;
P<sub>1</sub> = 1;
P<sub>n</sub> = 2 × P<sub>n-1</sub> + P<sub>n-2</sub>;
</span>
Or, may also be expressed by the closed form formula:
<span style="font-size:125%;font-weight:bold;">
P<sub>n</sub> = ((1 + √2)<sup>n</sup> - (1 - √2)<sup>n</sup>) / (2 × √2);
</span>
'''Pell-Lucas''' or '''Pell-companion numbers''': '''2, 2, 6, 14, 34, 82, etc.''', are defined by a very similar recurrence relation, differing only in the first two terms:
<span style="font-size:125%;font-weight:bold;">
Q<sub>0</sub> = 2;
Q<sub>1</sub> = 2;
Q<sub>n</sub> = 2 × Q<sub>n-1</sub> + Q<sub>n-2</sub>;
</span>
Or, may also be expressed by the closed form formula:
<span style="font-size:125%;font-weight:bold;">
Q<sub>n</sub> = (1 + √2)<sup>n</sup> + (1 - √2)<sup>n</sup>;
</span>
or
<span style="font-size:125%;font-weight:bold;">
Q<sub>n</sub> = P<sub>2n</sub> / P<sub>n</sub>;
</span>
The sequence of rational approximations to the square root of 2 begins:
<span style="font-size:125%;font-weight:bold;">
1/1, 3/2, 7/5, 17/12, 41/29, ...
</span>
Starting from '''n = 1''', for each term, the denominator is '''P<sub>n</sub>''' and the numerator is '''Q<sub>n</sub> / 2''' or '''P<sub>n-1</sub> + P<sub>n</sub>'''.
'''Pell primes''' are '''Pell numbers''' that are prime. '''Pell prime indices''' are the indices of the primes in the '''Pell numbers''' sequence. Every '''Pell prime''' index is prime, though not every prime index corresponds to a prime '''Pell number'''.
If you take the sum '''S''' of the first '''4n + 1''' '''Pell numbers''', the sum of the terms '''P<sub>2n</sub>''' and '''P<sub>2n + 1</sub>''' will form the square root of '''S'''.
For instance, the sum of the '''Pell numbers''' up to '''P<sub>5</sub>'''; '''0 + 1 + 2 + 5 + 12 + 29 == 49''', is the square of '''P<sub>2</sub> + P<sub>3</sub> == 2 + 5 == 7'''. The sequence of numbers formed by the sums '''P<sub>2n</sub> + P<sub>2n + 1</sub>''' are known as '''Newman-Shank-Williams numbers''' or '''NSW numbers'''.
'''Pell numbers''' may also be used to find Pythagorean triple '''near isosceles right triangles'''; right triangles whose legs differ by exactly '''1'''. E.G.: '''(3,4,5), (20,21,29), (119,120,169), etc.'''
For '''n > 0''', each right triangle hypotenuse is '''P<sub>2n + 1</sub>'''. The shorter leg length is the sum of the terms ''up to'' '''P<sub>2n + 1</sub>'''. The longer leg length is '''1''' more than that.
;Task
;* Find and show at least the first 10 '''Pell numbers'''.
;* Find and show at least the first 10 '''Pell-Lucas numbers'''.
;* Use the '''Pell''' (and optionally, '''Pell-Lucas''') '''numbers''' sequence to find and show at least the first 10 rational approximations to √2 in both rational and decimal representation.
;* Find and show at least the first 10 '''Pell primes'''.
;* Find and show at least the first 10 indices of '''Pell primes'''.
;* Find and show at least the first 10 '''Newman-Shank-Williams numbers'''
;* Find and show at least the first 10 Pythagorean triples corresponding to '''near isosceles right triangles'''.
;See also
;* [[wp:Pell_number|Wikipedia: Pell number]]
;* [[oeis:A000129|OEIS:A000129 - Pell numbers]]
;* [[oeis:A002203|OEIS:A002203 - Companion Pell numbers]] (Pell-Lucas numbers)
;* [[oeis:A001333|OEIS:A001333 - Numerators of continued fraction convergents to sqrt(2)]] (Companion Pell numbers / 2)
;* [[oeis:A086383|OEIS:A086383 - Prime terms in the sequence of Pell numbers]]
;* [[oeis:A096650|OEIS:A096650 - Indices of prime Pell numbers]]
;* [[oeis:A002315|OEIS:A002315 - NSW numbers]] (Newman-Shank-Williams numbers)
;* [[wp:Pythagorean_triple|Wikipedia: Pythagorean triple]]
;* [[Pythagorean triples]]

37
Task/Pell-numbers/Common-Lisp/pell-numbers-1.lisp Normal file
View file

@ -0,0 +1,37 @@
(defun recurrent-sequence-2 (a0 a1 k1 k2 max)
"A generic function for any recurrent sequence of order 2, where a0 and a1 are the initial elements,
k1 is the factor of a(n-1) and k2 is the factor of a(n-2)"
(do* ((i 0 (1+ i))
(result (list a1 a0))
(b0 a0 b1)
(b1 a1 b2)
(b2 (+ (* k1 b1) (* k2 b0)) (+ (* k1 b1) (* k2 b0))) )
((> i max) (nreverse result))
(push b2 result) ))
(defun pell-sequence (max)
(recurrent-sequence-2 0 1 2 1 max) )
(defun pell-lucas-sequence (max)
(recurrent-sequence-2 2 2 2 1 max) )
(defun fibonacci-sequence (max) ; As an extra bonus, you get Fibonacci's numbers with this simple call
(recurrent-sequence-2 1 1 1 1 max) )
(defun rational-approximation-sqrt2 (max)
"Approximate square root of 2 with (P(n-1)+P(n-2))/P(n)"
(butlast (maplist #'(lambda (l) (/ (+ (first l) (or (second l) 0)) (or (second l) 1))) (pell-sequence max))) )
(defun pell-primes (max)
(do* ((i 0 (1+ i))
(result (list 1 0))
(indices nil)
(b0 0 b1)
(b1 1 b2)
(b2 (+ (* 2 b1) (* 1 b0)) (+ (* 2 b1) (* 1 b0))) )
((> (length result) max) (values (nreverse result)(nreverse indices)))
; primep can be any function determining whether a number is prime, for example,
; https://rosettacode.org/wiki/Primality_by_Wilson%27s_theorem#Common_Lisp
(when (primep b2)
(push b2 result)
(push i indices) )))

2
Task/Pell-numbers/Common-Lisp/pell-numbers-2.lisp Normal file
View file

@ -0,0 +1,2 @@
(pell-sequence 10)
(0 1 2 5 12 29 70 169 408 985 2378 5741 13860)

2
Task/Pell-numbers/Common-Lisp/pell-numbers-3.lisp Normal file
View file

@ -0,0 +1,2 @@
(pell-lucas-sequence 10)
(2 2 6 14 34 82 198 478 1154 2786 6726 16238 39202)

3
Task/Pell-numbers/Common-Lisp/pell-numbers-4.lisp Normal file
View file

@ -0,0 +1,3 @@
(rational-approximation-sqrt2 10)
(1 3/2 7/5 17/12 41/29 99/70 239/169 577/408 1393/985 3363/2378 8119/5741
19601/13860)

3
Task/Pell-numbers/Common-Lisp/pell-numbers-5.lisp Normal file
View file

@ -0,0 +1,3 @@
(mapcar #'float (rational-approximation-sqrt2 10))
(1.0 1.5 1.4 1.4166666 1.4137931 1.4142857 1.4142011 1.4142157 1.4142132
1.4142137 1.4142135 1.4142135)

3
Task/Pell-numbers/Common-Lisp/pell-numbers-6.lisp Normal file
View file

@ -0,0 +1,3 @@
(pell-primes 7)
(0 1 2 5 29 5741 33461 44560482149) ;
(0 1 3 9 11 27)

70
Task/Pell-numbers/FreeBASIC/pell-numbers.basic Normal file
View file

@ -0,0 +1,70 @@
#define isOdd(a) (((a) and 1) <> 0)
Function isPrime(Byval ValorEval As Integer) As Boolean
If ValorEval < 2 Then Return False
If ValorEval Mod 2 = 0 Then Return ValorEval = 2
If ValorEval Mod 3 = 0 Then Return ValorEval = 3
Dim d As Integer = 5
While d * d <= ValorEval
If ValorEval Mod d = 0 Then Return False Else d += 2
If ValorEval Mod d = 0 Then Return False Else d += 4
Wend
Return True
End Function
Dim As Integer n
Dim As Integer p(0 To 40), pl(0 To 40)
p(0)= 0: p(1) = 1
pl(0) = 2: pl(1) = 2
For n = 2 To 40
p(n) = 2 * p(n-1) + p(n-2)
pl(n) = 2 * pl(n-1) + pl(n-2)
Next n
Print "First 20 Pell numbers: "
For n = 0 To 19 : Print p(n); : Next n
Print !"\n\nFirst 20 Pell-Lucas: "
For n = 0 To 19 : Print pl(n); : Next n
Print !"\n\nFirst 20 rational approximations of sqrt(2) (" & Str(Sqr(2)) & "): "
For n = 1 To 20
Dim As Integer j = pl(n)/2, d = p(n)
Print Using " &/& ~= &"; j; d; j/d
Next n
Print !"\nFirst 6 Pell primes: [for the limitations of the FB standard library]"
Dim as Integer pdx = 2
Dim As Byte c = 0
Dim As Ulongint ppdx(1 to 20)
do
If isPrime(p(pdx)) Then
If isPrime(pdx) Then ppdx(c) = pdx : End If
Print p(pdx)
c += 1
End If
pdx += 1
loop until c = 6
Print !"\nIndices of first 6 Pell primes: [for the limitations of the FB standard library]"
For n = 0 To 5 : Print " "; ppdx(n); : Next n
Dim As Ulongint nsw(0 To 20)
For n = 0 To 19
nsw(n) = p(2*n) + p(2*n+1)
Next n
Print !"\n\nFirst 20 Newman-Shank-Williams numbers: "
For n = 0 To 19 : Print " "; nsw(n); : Next n
Print !"\n\nFirst 20 near isosceles right triangles:"
Dim As Integer i0 = 0, i1 = 1, i2, t = 1, i = 2, found = 0
Do While found < 20
i2 = i1*2 + i0
If isOdd(i) Then
Print Using " [&, &, &]"; t; t+1 ; i2
found += 1
End If
t += i2
i0 = i1 : i1 = i2
i += 1
Loop
Sleep

74
Task/Pell-numbers/Go/pell-numbers.go Normal file
View file

@ -0,0 +1,74 @@
package main
import (
"fmt"
"math/big"
"rcu"
)
func main() {
p := make([]int64, 40)
p[1] = 1
for i := 2; i < 40; i++ {
p[i] = 2*p[i-1] + p[i-2]
}
fmt.Println("The first 20 Pell numbers are:")
fmt.Println(p[0:20])
q := make([]int64, 40)
q[0] = 2
q[1] = 2
for i := 2; i < 40; i++ {
q[i] = 2*q[i-1] + q[i-2]
}
fmt.Println("\nThe first 20 Pell-Lucas numbers are:")
fmt.Println(q[0:20])
fmt.Println("\nThe first 20 rational approximations of √2 (1.4142135623730951) are:")
for i := 1; i <= 20; i++ {
r := big.NewRat(q[i]/2, p[i])
fmt.Printf("%-17s ≈ %-18s\n", r, r.FloatString(16))
}
fmt.Println("\nThe first 15 Pell primes are:")
p0 := big.NewInt(0)
p1 := big.NewInt(1)
p2 := big.NewInt(0)
two := big.NewInt(2)
indices := make([]int, 15)
for index, count := 2, 0; count < 15; index++ {
p2.Mul(p1, two)
p2.Add(p2, p0)
if rcu.IsPrime(index) && p2.ProbablyPrime(15) {
fmt.Println(p2)
indices[count] = index
count++
}
p0.Set(p1)
p1.Set(p2)
}
fmt.Println("\nIndices of the first 15 Pell primes are:")
fmt.Println(indices)
fmt.Println("\nFirst 20 Newman-Shank_Williams numbers:")
nsw := make([]int64, 20)
for n := 0; n < 20; n++ {
nsw[n] = p[2*n] + p[2*n+1]
}
fmt.Println(nsw)
fmt.Println("\nFirst 20 near isosceles right triangles:")
u0 := 0
u1 := 1
sum := 1
for i := 2; i < 43; i++ {
u2 := u1*2 + u0
if i%2 == 1 {
fmt.Printf("(%d, %d, %d)\n", sum, sum+1, u2)
}
sum += u2
u0 = u1
u1 = u2
}
}

57
Task/Pell-numbers/Haskell/pell-numbers.hs Normal file
View file

@ -0,0 +1,57 @@
import Data.Numbers.Primes (isPrime)
----------------------- PELL SERIES ----------------------
pell :: Integer -> Integer -> [Integer]
pell a b = a : b : zipWith (+) (pell a b) ((2 *) <$> tail (pell a b))
a000129, a002203, a001333, a086383, a096650, a002315 :: [Integer]
a000129 = pell 0 1
a002203 = pell 2 2
a001333 = (`div` 2) <$> a002203
a086383 = filter isPrime a000129
a096650 = zip [0 ..] a000129 >>= (\(i, n) -> [i | isPrime n])
a002315 = 1 : 7 : zipWith (-) ((6 *) <$> tail a002315) a002315
------------------- PYTHAGOREAN TRIPLES ------------------
pythagoreanTriples :: [(Integer, Integer, Integer)]
pythagoreanTriples =
(tail . concat) $ zipWith3 go [0 ..] a000129 (scanl (+) 0 a000129)
where
go i p m
| odd i = [(m, succ m, p)]
| otherwise = []
-------------------------- TESTS -------------------------
main :: IO ()
main = do
mapM_
(\(k, xs) -> putStrLn ('\n' : k) >> print (take 10 xs))
[ ("a000129", a000129)
, ("a002203", a002203)
, ("a001333", a001333)
-- Waste of electrical power ?
-- ("a086383", a086383)
-- ("a096650", a096650
, ("a002315", a002315)
]
putStrLn "\nRational approximations to sqrt 2:"
mapM_ putStrLn $
(take 10 . tail) $
zipWith
(\n d ->
show n <>
('/' : show d) <> " -> " <> show (fromIntegral n / fromIntegral d))
a001333
a000129
putStrLn "\nPythagorean triples:"
mapM_ print $ take 10 pythagoreanTriples

5
Task/Pell-numbers/J/pell-numbers-1.j Normal file
View file

@ -0,0 +1,5 @@
nextPell=: , 1 2+/ .*_2&{. NB. pell, list extender
Pn=: (%:8) %~(1+%:2)&^ - (1-%:2)&^ NB. pell, closed form
Qn=: (1+%:2)&^ + (1-%:2)&^ NB. pell lucas, closed form
QN=: +: %&Pn ] NB. pell lucas, closed form
qn=: 2 * (+&Pn <:) NB. pell lucas, closed form

12
Task/Pell-numbers/J/pell-numbers-2.j Normal file
View file

@ -0,0 +1,12 @@
nextPell^:9(0 1)
0 1 2 5 12 29 70 169 408 985 2378
Pn i.11
0 1 2 5 12 29 70 169 408 985 2378
nextPell^:9(2 2)
2 2 6 14 34 82 198 478 1154 2786 6726
Qn i.11
2 2 6 14 34 82 198 478 1154 2786 6726
QN i.11
0 2 6 14 34 82 198 478 1154 2786 6726
qn i.11
2 2 6 14 34 82 198 478 1154 2786 6726

3
Task/Pell-numbers/J/pell-numbers-3.j Normal file
View file

@ -0,0 +1,3 @@
QN=: 2 >. +: %&Pn ]
QN i.11
2 2 6 14 34 82 198 478 1154 2786 6726

4
Task/Pell-numbers/J/pell-numbers-4.j Normal file
View file

@ -0,0 +1,4 @@
}.(%~ _1}. +//.@,:~) nextPell^:9(0 1)
1 1.5 1.4 1.41667 1.41379 1.41429 1.4142 1.41422 1.41421 1.41421
}.(%~ _1}. +//.@,:~) nextPell^:9(0 1x)
1 3r2 7r5 17r12 41r29 99r70 239r169 577r408 1393r985 3363r2378

2
Task/Pell-numbers/J/pell-numbers-5.j Normal file
View file

@ -0,0 +1,2 @@
10{.(#~ 1&p:)nextPell^:99(0 1x)
2 5 29 5741 33461 44560482149 1746860020068409 68480406462161287469 13558774610046711780701 4125636888562548868221559797461449

2
Task/Pell-numbers/J/pell-numbers-6.j Normal file
View file

@ -0,0 +1,2 @@
10{.I. 1&p:nextPell^:99(0 1x)
2 3 5 11 13 29 41 53 59 89

2
Task/Pell-numbers/J/pell-numbers-7.j Normal file
View file

@ -0,0 +1,2 @@
_2 +/\ nextPell^:20(0 1x)
1 7 41 239 1393 8119 47321 275807 1607521 9369319 54608393

11
Task/Pell-numbers/J/pell-numbers-8.j Normal file
View file

@ -0,0 +1,11 @@
}.(21$1 0)#|:(}.,~0 1+/+/\@}:)nextPell^:(20)0 1
3 4 5
20 21 29
119 120 169
696 697 985
4059 4060 5741
23660 23661 33461
137903 137904 195025
803760 803761 1136689
4684659 4684660 6625109
27304196 27304197 38613965

66
Task/Pell-numbers/Julia/pell-numbers.julia Normal file
View file

@ -0,0 +1,66 @@
using Primes
function pellnumbers(wanted)
pells = [0, 1]
wanted < 3 && return pells[1:wanted]
while length(pells) < wanted
push!(pells, 2 * pells[end] + pells[end - 1])
end
return pells
end
function pelllucasnumbers(wanted)
pelllucas = [2, 2]
wanted < 3 && return pelllucas[1:wanted]
while length(pelllucas) < wanted
push!(pelllucas, 2 * pelllucas[end] + pelllucas[end - 1])
end
return pelllucas
end
function pellprimes(wanted)
i, lastpell, lastlastpell, primeindices, pellprimes = 1, big"1", big"0", Int[], BigInt[]
while length(primeindices) < wanted
pell = 2 * lastpell + lastlastpell
i += 1
if isprime(pell)
push!(primeindices, i)
push!(pellprimes, pell)
end
lastpell, lastlastpell = pell, lastpell
end
return primeindices, pellprimes
end
function approximationsqrt2(wanted)
p, q = pellnumbers(wanted + 1), pelllucasnumbers(wanted + 1)
return map(r -> "$r ≈ $(Float64(r))", [(q[n] // 2) // p[n] for n in 2:wanted+1])
end
function newmanshankwilliams(wanted)
pells = pellnumbers(wanted * 2 + 1)
return [pells[2i - 1] + pells[2i] for i in 1:wanted]
end
function nearisosceles(wanted)
pells = pellnumbers((wanted + 1) * 2 + 1)
return map(x -> (last(x), last(x) + 1, first(x)),
[(pells[2i], sum(pells[1:2i-1])) for i in 2:wanted+1])
end
function printrows(title, vec, columnsize = 8, columns = 10, rjust=false)
println(title)
for (i, n) in enumerate(vec)
print((rjust ? lpad : rpad)(n, columnsize), i % columns == 0 ? "\n" : "")
end
println()
end
printrows("Twenty Pell numbers:", pellnumbers(20))
printrows("Twenty Pell-Lucas numbers:", pelllucasnumbers(20))
printrows("Twenty approximations of √2:", approximationsqrt2(20), 44, 2)
pindices, pprimes = pellprimes(15)
printrows("Fifteen Pell primes:", pprimes, 90, 1)
printrows("Fifteen Pell prime zero-based indices:", pindices, 4, 15)
printrows("Twenty Newman-Shank-Williams numbers:", newmanshankwilliams(20), 17, 5)
printrows("Twenty near isosceles triangle triplets:", nearisosceles(20), 52, 2)

33
Task/Pell-numbers/Mathematica/pell-numbers.math Normal file
View file

@ -0,0 +1,33 @@
ClearAll[PellNumber, PellLucasNumber]
PellNumber[0] = 0;
PellNumber[1] = 1;
PellNumber[n_] := PellNumber[n] = 2 PellNumber[n - 1] + PellNumber[n - 2]
PellLucasNumber[0] = 2;
PellLucasNumber[1] = 2;
PellLucasNumber[n_] := PellLucasNumber[n] = 2 PellLucasNumber[n - 1] + PellLucasNumber[n - 2]
pns = PellNumber /@ Range[0, 9]
plns = PellLucasNumber /@ Range[0, 9]
den = Rest@pns;
num = Rest@plns/2;
approx = num/den
N[approx]
pns = {#, PellNumber[#]} & /@ Range[0, 100];
Select[pns, Last/*PrimeQ, 10] // Grid
ClearAll[PellS]
PellS[n_] := If[n == 0, 1, PellNumber[2 n] + PellNumber[2 n + 1]]
PellS /@ Range[0, 19]
ClearAll[PythagoreanTriple]
PythagoreanTriple[n_Integer] := Module[{hypo, short, long},
hypo = PellNumber[2 n + 1];
short = Total[PellNumber /@ Range[2 n]];
long = short + 1;
{short, long, hypo}
]
PythagoreanTriple /@ Range[10]

76
Task/Pell-numbers/Nim/pell-numbers.nim Normal file
View file

@ -0,0 +1,76 @@
import std/[strformat, strutils, sugar]
import integers
template isOdd(n: int): bool = (n and 1) != 0
iterator pellSequence[T](first, second: T; lim = -1): (int, T) =
## Yield the sucessive values of a Pell or Pell-Lucas sequence
## preceded by their rank.
## If "lim" is specified and greater than 2, only the "lim" first
## values are computed.
## The iterator works with "int" values or "Integer" values.
var prev = first
var curr = second
yield (0, prev)
yield (1, curr)
var count = 2
while true:
swap prev, curr
curr += 2 * prev
yield (count, curr)
inc count
if count == lim: break
echo "First 10 Pell numbers:"
let p = collect:
for (idx, val) in pellSequence(0, 1, 11): val
echo p[0..9].join(" ")
echo "\nFirst 10 Pell-Lucas numbers:"
let q = collect:
for (idx, val) in pellSequence(2, 2, 11): val
echo q[0..9].join(" ")
echo "\nFirst 10 rational approximations of √2:"
for i in 1..10:
let n = q[i] div 2
let d = p[i]
let r = &"{n}/{d}"
echo &"{r:>9} = {n/d:.17}"
echo "\nFirst 10 Pell primes:"
# To avoid an overflow, we need to use Integer values here.
var indices: seq[int]
var count = 0
for (idx, p) in pellSequence(newInteger(0), newInteger(1)):
if p.isPrime:
echo p
indices.add idx
inc count
if count == 10: break
echo "\nFirst 10 Pell primes indices:"
echo indices.join(" ")
echo "\nFirst 10 Newman-Shank-Williams numbers:"
count = 0
var prev: int
for (idx, p) in pellSequence(0, 1):
if idx.isOdd:
inc count
stdout.write prev + p
if count == 10: break
stdout.write ' '
else:
prev = p
echo()
echo "\nFirst 10 near isosceles right triangles:"
count = 0
var sum = 0
for (idx, p) in pellSequence(0, 1):
if idx.isOdd and sum != 0:
echo (sum, sum + 1, p)
inc count
if count == 10: break
inc sum, p

43
Task/Pell-numbers/Perl/pell-numbers.pl Normal file
View file

@ -0,0 +1,43 @@
use strict;
use warnings;
use feature <state say>;
use bignum;
use ntheory 'is_prime';
use List::Util <sum head>;
use List::Lazy 'lazy_list';
my $upto = 20;
my $pell_recur = lazy_list { state @p = (0, 1); push @p, 2*$p[1] + $p[0]; shift @p };
my $pell_lucas_recur = lazy_list { state @p = (2, 2); push @p, 2*$p[1] + $p[0]; shift @p };
my @pell;
push @pell, $pell_recur->next() for 1..1500; #wart;
my @pell_lucas;
push @pell_lucas, $pell_lucas_recur->next() for 1..$upto+1;
say "First $upto Pell numbers:";
say join ' ', @pell[0..$upto-1];
say "\nFirst $upto Pell-Lucas numbers:";
say join ' ', @pell_lucas[0..$upto-1];
say "\nFirst $upto rational approximations of √2:";
say sprintf "%d/%d - %1.16f", $pell[$_-1] + $pell[$_], $pell[$_], ($pell[$_-1]+$pell[$_])/$pell[$_] for 1..$upto;
say "\nFirst $upto Pell primes:";
say join "\n", head $upto, grep { is_prime $_ } @pell;
say "\nIndices of first $upto Pell primes:";
say join ' ', head $upto, grep { is_prime($pell[$_]) and $_ } 0..$#pell;
say "\nFirst $upto Newman-Shank-Williams numbers:";
say join ' ', map { $pell[2 * $_] + $pell[2 * $_+1] } 0..$upto-1;
say "\nFirst $upto near isoceles right tringles:";
map {
my $y = 2*$_ + 1;
my $x = sum @pell[0..$y-1];
printf "(%d, %d, %d)\n", $x, $x+1, $pell[$y]
} 1..$upto;

42
Task/Pell-numbers/Phix/pell-numbers.phix Normal file
View file

@ -0,0 +1,42 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},</span>
<span style="color: #000000;">pl</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">41</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">p</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]+</span><span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">pl</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">pl</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]+</span><span style="color: #000000;">pl</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First 20 Pell numbers: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">20</span><span style="color: #0000FF;">],</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">:=</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First 20 Pell-Lucas: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pl</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">20</span><span style="color: #0000FF;">],</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">:=</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First 20 rational approximations of sqrt(2) (%.16f):\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">21</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">pl</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d/%d ~= %.16g\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">d</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">d</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nFirst 20 Pell primes:\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">mpz</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">p0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">})</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">ppdx</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">pdx</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">2</span>
<span style="color: #008080;">while</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ppdx</span><span style="color: #0000FF;">)<</span><span style="color: #000000;">20</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p0</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pdx</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">mpz_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">mpz_get_short_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">))</span>
<span style="color: #000000;">ppdx</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ppdx</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pdx</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">pdx</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #7060A8;">mpz_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p1</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p2</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nIndices of first 20 Pell primes: %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ppdx</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">))</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">nsw</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20</span> <span style="color: #008080;">do</span> <span style="color: #000000;">nsw</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">nsw</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]+</span><span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">*</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">nsw</span><span style="color: #0000FF;">[</span><span style="color: #000000;">8</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">3</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"..."</span><span style="color: #0000FF;">}</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nFirst 20 Newman-Shank-Williams numbers: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">nsw</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nFirst 20 near isosceles right triangles:\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">4</span> <span style="color: #008080;">to</span> <span style="color: #000000;">42</span> <span style="color: #008080;">by</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">side</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]),</span> <span style="color: #000000;">hypot</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"[%d, %d, %d]\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">side</span><span style="color: #0000FF;">,</span><span style="color: #000000;">side</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hypot</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--

100
Task/Pell-numbers/Quackery/pell-numbers.quackery Normal file
View file

@ -0,0 +1,100 @@
[ $ "bigrat.qky" loadfile ] now!
[ ' [ 0 ] swap
witheach
[ over -1 peek
+ join ]
behead drop ] is cumsum ( [ --> [ )
[ dup -1 peek 2 *
over -2 peek + join ] is nextterm ( [ --> [ )
[ over 2 - times
nextterm
swap split drop ] is sequence ( n [ --> [ )
[ ' [ 0 1 ] sequence ] is pells ( n --> [ )
[ ' [ 2 2 ] sequence ] is companions ( n --> [ )
[ [] swap 1+
dup companions
behead drop
swap pells
behead drop
witheach
[ dip
[ behead 2 / ]
join nested
rot swap join
swap ]
drop ] is rootytwos ( n --> [ )
[ stack ] is index ( --> s )
[ temp put
1 index put
[] ' [ 0 1 ]
[ 1 index tally
over size
temp share < while
nextterm
behead drop
index share
isprime until
dup -1 peek
dup isprime iff
[ swap dip
[ index share
swap join
nested join ] ]
else drop
again ]
drop
index release
temp release ] is pellprimes ( n --> [ )
[ [] over 2 * pells
rot times
[ behead dip behead +
join ]
nip ] is nsws ( n --> [ )
[ [] swap 1+ dup
2 * 1+ pells
dup cumsum
swap rot times
[ over i^ 2 * peek
dup 1+ join
over i^ 2 * 1+ peek
join
dip rot nested join
unrot ]
2drop behead drop ] is nirts ( n --> [ )
say "Pell numbers " 10 pells echo
cr cr
say "Pell-Lucas's " 10 companions echo
cr cr
say "Approximations of sqrt(2)"
cr
10 rootytwos
witheach
[ do 2dup
vulgar$ echo$ sp
10 point$ echo$ cr ]
cr
say "Pell Primes "
7 pellprimes dup
[] swap
witheach [ 1 peek join ] echo
cr
say "their indices "
[] swap
witheach [ 0 peek join ] echo
cr cr
say "NSW numbers " 10 nsws echo
cr cr
say "Near isosceles right triangles"
cr
10 nirts witheach [ echo cr ]

20
Task/Pell-numbers/Raku/pell-numbers.raku Normal file
View file

@ -0,0 +1,20 @@
my $pell = cache lazy 0, 1, * + * × 2 … *;
my $pell-lucas = lazy 2, 2, * + * × 2 … *;
my $upto = 20;
say "First $upto Pell numbers:\n" ~ $pell[^$upto];
say "\nFirst $upto Pell-Lucas numbers:\n" ~ $pell-lucas[^$upto];
say "\nFirst $upto rational approximations of √2 ({sqrt(2)}):\n" ~
(1..$upto).map({ sprintf "%d/%d - %1.16f", $pell[$_-1] + $pell[$_], $pell[$_], ($pell[$_-1]+$pell[$_])/$pell[$_] }).join: "\n";
say "\nFirst $upto Pell primes:\n" ~ $pell.grep(&is-prime)[^$upto].join: "\n";
say "\nIndices of first $upto Pell primes:\n" ~ (^∞).grep({$pell[$_].is-prime})[^$upto];
say "\nFirst $upto Newman-Shank-Williams numbers:\n" ~ (^$upto).map({ $pell[2 × $_, 2 × $_+1].sum });
say "\nFirst $upto near isosceles right triangles:";
map -> \p { printf "(%d, %d, %d)\n", |($_, $_+1 given $pell[^(2 × p + 1)].sum), $pell[2 × p + 1] }, 1..$upto;

62
Task/Pell-numbers/Scala/pell-numbers.scala Normal file
View file

@ -0,0 +1,62 @@
val pellNumbers: LazyList[BigInt] =
BigInt("0") #:: BigInt("1") #::
(pellNumbers zip pellNumbers.tail).
map{ case (a,b) => 2*b + a }
val pellLucasNumbers: LazyList[BigInt] =
BigInt("2") #:: BigInt("2") #::
(pellLucasNumbers zip pellLucasNumbers.tail).
map{ case (a,b) => 2*b + a }
val pellPrimes: LazyList[BigInt] =
pellNumbers.tail.tail.
filter{ case p => p.isProbablePrime(16) }
val pellIndexOfPrimes: LazyList[BigInt] =
pellNumbers.tail.tail.
filter{ case p => p.isProbablePrime(16) }.
map{ case p => pellNumbers.indexOf(p) }
val pellNSWnumbers: LazyList[BigInt] =
(pellNumbers.zipWithIndex.collect{ case (p,i) if i%2 == 0 => p}
zip
pellNumbers.zipWithIndex.collect{ case (p,i) if i%2 != 0 => p}).
map{ case (a,b) => a + b }
val pellSqrt2Numerator: LazyList[BigInt] =
BigInt(1) #:: BigInt(3) #::
(pellSqrt2Numerator zip pellSqrt2Numerator.tail).
map{ case (a,b) => 2*b + a }
val pellSqrt2: LazyList[BigDecimal] =
(pellSqrt2Numerator zip pellNumbers.tail).
map{ case (n,d) => BigDecimal(n)/BigDecimal(d) }
val pellSqrt2asString: LazyList[String] =
(pellSqrt2Numerator zip pellNumbers.tail).
map{ case (n,d) => s"$n/$d" }
val pellHypotenuse: LazyList[BigInt] =
pellNumbers.tail.tail.zipWithIndex.collect{ case (p,i) if i%2 != 0 => p }
val pellShortLeg: LazyList[BigInt] =
LazyList.from(3,2).map{ case s => pellNumbers.take(s).sum }
val pellTriple: LazyList[(BigInt,BigInt,BigInt)] =
(pellHypotenuse zip pellShortLeg).
map{ case (h,s) => (s,s+1,h)}
// Output
{ println("7 Tasks")
println("-------")
println(pellNumbers.take(10).mkString("1. Pell Numbers: ", ",", "\n"))
println(pellLucasNumbers.take(10).mkString("2. Pell-Lucas Numbers: ", ",", "\n"))
println((pellSqrt2asString zip pellSqrt2).take(10).
map { case (f, d) => s"$f = $d" }.
mkString("3. Square-root of 2 Approximations: \n\n",
"\n", "\n"))
println(pellPrimes.take(10).mkString("4. Pell Primes: \n\n", "\n", "\n"))
println(pellIndexOfPrimes.take(10).mkString("5. Pell Index of Primes: ", ",", "\n"))
println(pellNSWnumbers.take(10).mkString("6. Newman-Shank-Williams Numbers: \n\n", "\n", "\n"))
println(pellTriple.take(10).mkString("7. Near Right-triangle Triples: \n\n", "\n", "\n"))
}

66
Task/Pell-numbers/Wren/pell-numbers.wren Normal file
View file

@ -0,0 +1,66 @@
import "./big" for BigInt, BigRat
import "./math" for Int
import "./fmt" for Fmt
var p = List.filled(40, 0)
p[0] = 0
p[1] = 1
for (i in 2..39) p[i] = 2 * p[i-1] + p[i-2]
System.print("The first 20 Pell numbers are:")
System.print(p[0..19].join(" "))
var q = List.filled(40, 0)
q[0] = 2
q[1] = 2
for (i in 2..39) q[i] = 2 * q[i-1] + q[i-2]
System.print("\nThe first 20 Pell-Lucas numbers are:")
System.print(q[0..19].join(" "))
System.print("\nThe first 20 rational approximations of √2 (1.4142135623730951) are:")
for (i in 1..20) {
var r = BigRat.new(q[i]/2, p[i])
Fmt.print("$-17s ≈ $-18s", r, r.toDecimal(16, true, true))
}
System.print("\nThe first 15 Pell primes are:")
var p0 = BigInt.zero
var p1 = BigInt.one
var indices = List.filled(15, 0)
var count = 0
var index = 2
var p2
while (count < 15) {
p2 = p1 * BigInt.two + p0
if (Int.isPrime(index) && p2.isProbablePrime(10)) {
System.print(p2)
indices[count] = index
count = count + 1
}
index = index + 1
p0 = p1
p1 = p2
}
System.print("\nIndices of the first 15 Pell primes are:")
System.print(indices.join(" "))
System.print("\nFirst 20 Newman-Shank_Williams numbers:")
var nsw = List.filled(20, 0)
for (n in 0..19) nsw[n] = p[2*n] + p[2*n+1]
Fmt.print("$d", nsw)
System.print("\nFirst 20 near isosceles right triangles:")
p0 = 0
p1 = 1
var sum = 1
var i = 2
while (i < 43) {
p2 = p1 * 2 + p0
if (i % 2 == 1) {
Fmt.print("($d, $d, $d)", sum, sum + 1, p2)
}
sum = sum + p2
p0 = p1
p1 = p2
i = i + 1
}