Rosetta Code

Pierpont primes: Difference between revisions

Page Discussion

Pierpont primes (view source)

Revision as of 11:47, 25 January 2024

14,344 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(19 intermediate revisions by 13 users not shown)
Line 31:
=={{header|ALGOL 68}}==
As in the second Go sample, generates the 3-smooth number sequence to find Pierpoint Prime candidates. Uses a sliding window on the sequence to avoid having to keep it all in memory.
{{libheader|ALGOL 68-primes}}
<lang algol68>BEGIN # find some pierpoint primes of the first kind (2^u3^v + 1) #
<syntaxhighlight lang="algol68">BEGIN # find some pierpoint primes of the first kind (2^u3^v + 1) #
# and second kind (2^u3^v - 1) #
# construct a sieve of primes up to 10 000 #
PR read "primes.incl.a68" PR
[ 1 : 10 000 ]BOOL prime;
prime[ 1 ] := FALSE;BOOL prime[ 2= ]PRIMESIEVE :=10 TRUE000;
FOR i FROM 3 BY 2 TO UPB prime DO prime[ i ] := TRUE OD;
FOR i FROM 4 BY 2 TO UPB prime DO prime[ i ] := FALSE OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( UPB prime ) DO
IF prime[ i ] THEN FOR s FROM i * i BY i + i TO UPB prime DO prime[ s ] := FALSE OD FI
OD;
# returns the minimum of a and b #
PROC min = ( INT a, b )INT: IF a < b THEN a ELSE b FI;
Line 131 ⟶ 127:
print pierpoint( pfirst, "First" );
print pierpoint( psecond, "Second" )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 151 ⟶ 147:
=={{header|C}}==
{{trans|D}}
<langsyntaxhighlight lang="c">#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
Line 274 ⟶ 270:
}
printf("\n");
}</langsyntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
Line 291 ⟶ 287:
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Numerics;
Line 463 ⟶ 459:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
Line 484 ⟶ 480:
=={{header|C++}}==
{{libheader|GMP}}
<langsyntaxhighlight lang="cpp">#include <cassert>
#include <algorithm>
#include <iomanip>
Line 576 ⟶ 572:
std::cout << "250th Pierpont prime of the second kind: " << p2 << '\n';
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 600 ⟶ 596:
=={{header|D}}==
{{trans|C#}}
<langsyntaxhighlight lang="d">import std.algorithm;
import std.bigint;
import std.random;
Line 764 ⟶ 760:
writefln("%dth Pierpont prime of the first kind: %d", p[0].length, p[0][$ - 1]);
writefln("%dth Pierpont prime of the second kind: %d", p[1].length, p[1][$ - 1]);
}</langsyntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
Line 792 ⟶ 788:
{{Trans|Go}}
Thanks Rudy Velthuis for the [https://github.com/rvelthuis/DelphiBigNumbers Velthuis.BigIntegers.Primes and Velthuis.BigIntegers] library.<br>
<syntaxhighlight lang="delphi">
<lang Delphi>
program Pierpont_primes;
 
Line 863 ⟶ 859:
 
readln;
end.</langsyntaxhighlight>
=={{header|F_Sharp|F#}}==
This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>
<langsyntaxhighlight lang="fsharp">
// Pierpont primes . Nigel Galloway: March 19th., 2021
let fN g=let mutable g=g in ((fun()->g),fun()->g<-g+g;())
Line 876 ⟶ 872:
pierpontT1|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""
pierpontT2|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 883 ⟶ 879:
</pre>
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: fry grouping io kernel locals make math math.functions
math.primes prettyprint sequences sorting ;
 
Line 911 ⟶ 907:
"250th Pierpont prime of the second kind: " write
249 second nth .
]</langsyntaxhighlight>
{{out}}
<pre>
Line 934 ⟶ 930:
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">#define NPP 50
{{output?}}
<lang freebasic>#define NPP 50
 
Function isPrime(Byval n As Ulongint) As Boolean
function is_prime( n as ulongint ) as boolean
ifIf n < 2 thenThen returnReturn false
ifIf n = 2 thenThen returnReturn true
ifIf n modMod 2 = 0 thenThen returnReturn false
forFor i asAs uintegerUinteger = 3 toTo intInt(sqrSqr(n))+1 stepStep 2
ifIf n modMod i = 0 thenThen returnReturn false
nextNext i
returnReturn true
End Function
end function
 
functionFunction is_23( byvalByval n as uintegerAs Uinteger) asAs booleanBoolean
whileWhile n modMod 2 = 0
n = n /= 2
wendWend
whileWhile n modMod 3 = 0
n = n /= 3
wendWend
ifReturn Iif(n = 1 then return, true else return, false)
End Function
end function
 
Function isPierpont(n As Uinteger) As Uinteger
function is_pierpont( n as uinteger ) as uinteger
ifIf notNot is_primeisPrime(n) thenThen returnReturn 0 'not prime
dimDim asAs integerUinteger p1 = is_23(n+1), p2 = is_23(n-1)
ifIf p1 andAnd p2 thenThen returnReturn 3 'pierpont prime of both kinds
ifIf p1 thenThen returnReturn 1 'pierpont prime of the 1st kind
ifIf p2 thenThen returnReturn 2 'pierpont prime of the 2nd kind
returnReturn 0 'prime, but not pierpont
End Function
end function
 
dimDim asAs uintegerUinteger pier(1 toTo 2, 1 toTo NPP), np(1 toTo 2) = {0, 0}, x = 1, j
Dim As Uinteger x = 1, j
while np(1)<=NPP or np(2)<=NPP
While np(1) <= NPP Or np(2) <= NPP
x = x + 1
jx += is_pierpont(x)1
if j>0 then= isPierpont(x)
ifIf j mod 2 = 1> then0 Then
If j Mod 2 = 1 Then
np(1) += 1
ifIf np(1) <= NPP thenThen pier(1, np(1)) = x
endEnd ifIf
ifIf j > 1 thenThen
np(2) += 1
ifIf np(2) <= NPP thenThen pier(2, np(2)) = x
endEnd ifIf
endEnd ifIf
Wend
wend
 
printPrint " First 50 Pierpoint primes of the first Secondkind:"
forFor j = 1 toTo NPP
printPrint j,Using pier(1," j),########"; pier(2, j);
If j Mod 10 = 0 Then Print
next j</lang>
Next j
Print !"\nFirst 50 Pierpoint primes of the secod kind:"
For j = 1 To NPP
Print Using " ########"; pier(1, j);
If j Mod 10 = 0 Then Print
Next j
</syntaxhighlight>
{{out}}
<pre>
First 50 Pierpont primes of the first kind:
2 3 5 7 13 17 19 37 73 97
109 163 193 257 433 487 577 769 1153 1297
1459 2593 2917 3457 3889 10369 12289 17497 18433 39367
52489 65537 139969 147457 209953 331777 472393 629857 746497 786433
839809 995329 1179649 1492993 1769473 1990657 2654209 5038849 5308417 8503057
 
First 50 Pierpont primes of the second kind:
2 3 5 7 11 17 23 31 47 53
71 107 127 191 383 431 647 863 971 1151
2591 4373 6143 6911 8191 8747 13121 15551 23327 27647
62207 73727 131071 139967 165887 294911 314927 442367 472391 497663
524287 786431 995327 1062881 2519423 10616831 17915903 18874367 25509167 30233087
</pre>
 
=={{header|Go}}==
Line 996 ⟶ 1,015:
 
However, in order to be sure that the first 250 Pierpont primes will be generated, it is necessary to choose the loop sizes to produce somewhat more than this and then sort them into order.
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,057 ⟶ 1,076:
fmt.Println("\n250th Pierpont prime of the first kind:", pp[249])
fmt.Println("\n250th Pierpont prime of the second kind:", pp2[249])
}</langsyntaxhighlight>
 
{{out}}
Line 1,089 ⟶ 1,108:
These timings are for my Celeron @1.6GHz and should therefore be much faster on a more modern machine.
 
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,181 ⟶ 1,200:
elapsed := time.Now().Sub(start)
fmt.Printf("\nTook %s\n", elapsed)
}</langsyntaxhighlight>
 
{{out}}
Line 1,217 ⟶ 1,236:
Uses arithmoi Library: https://hackage.haskell.org/package/arithmoi-0.11.0.0 for prime generation and prime testing.<br>
n-smooth generation function based on [[Hamming_numbers#Avoiding_generation_of_duplicates]]
<langsyntaxhighlight lang="haskell">import Control.Monad (guard)
import Data.List (intercalate)
import Data.List.Split (chunksOf)
Line 1,257 ⟶ 1,276:
where
rows = chunksOf 10 . take 50
commas = reverse . intercalate "," . chunksOf 3 . reverse . show</langsyntaxhighlight>
{{out}}
<pre>
Line 1,280 ⟶ 1,299:
./pierpoints 0.04s user 0.01s system 20% cpu 0.215 total
</pre>
 
=={{header|J}}==
 
Implementation (first kind first):
 
<syntaxhighlight lang="j"> 5 10$(#~ 1 p:])1+/:~,*//2 3x^/i.20
2 3 5 7 13 17 19 37 73 97
109 163 193 257 433 487 577 769 1153 1297
1459 2593 2917 3457 3889 10369 12289 17497 18433 39367
52489 65537 139969 147457 209953 331777 472393 629857 746497 786433
839809 995329 1179649 1492993 1769473 1990657 2654209 5038849 5308417 8503057
5 10$(#~ 1 p:])_1+/:~,*//2 3x^/i.20
2 3 5 7 11 17 23 31 47 53
71 107 127 191 383 431 647 863 971 1151
2591 4373 6143 6911 8191 8747 13121 15551 23327 27647
62207 73727 131071 139967 165887 294911 314927 442367 472391 497663
524287 786431 995327 1062881 2519423 10616831 17915903 25509167 30233087 57395627</syntaxhighlight>
 
and
 
<syntaxhighlight lang="j"> 249{ (#~ 1 p:])1+/:~,*//2 3x^/i.112
62518864539857068333550694039553
249{ (#~ 1 p:])_1+/:~,*//2 3x^/i.112
4111131172000956525894875083702271</syntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">
import java.math.BigInteger;
import java.text.NumberFormat;
Line 1,348 ⟶ 1,391:
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,387 ⟶ 1,430:
 
'''Preliminaries'''
<langsyntaxhighlight lang="jq">def is_prime:
. as $n
| if ($n < 2) then false
Line 1,411 ⟶ 1,454:
 
def table($ncols; $colwidth):
nwise($ncols) | map(lpad($colwidth)) | join(" ");</langsyntaxhighlight>
'''Pierpont primes'''
<langsyntaxhighlight lang="jq"># Input: the target number of primes of the form p(u,v) == 2^u * 3^v ± 1.
# The main idea is to let u run from 0:m and v run from 0:n where n ~~ 0.63 * m.
# Initially we start with plausible values for m and n ($maxm and $maxn respectively),
Line 1,426 ⟶ 1,469:
# where .p is prime and .m and .n are the corresponding powers of 2 and 3
| def pp:
debug. as [$maxm, $maxn]
| [ ({p2:1, m:0},
(foreach range(0; $maxm) as $m (1; . * 2; {p2: ., m: ($m + 1)}))) as $a
Line 1,477 ⟶ 1,520:
50
| "\nThe first \(.) Pierpoint primes of the first kind:", (pierponts(true) | table(10;8)),
"\nThe first \(.) Pierpoint primes of the second kind:", (pierponts(false) | table(10;8))</langsyntaxhighlight>
{{out}}
<pre>
Line 1,497 ⟶ 1,540:
=={{header|Julia}}==
The generator method is very fast but does not guarantee the primes are generated in order. Therefore we generate two times the primes needed and then sort and return the lower half.
<langsyntaxhighlight lang="julia">using Primes
 
function pierponts(N, firstkind = true)
Line 1,529 ⟶ 1,572:
 
println("\nThe 2000th Pierpont prime (second kind) is: ", pierponts(2000, false)[2000])
</langsyntaxhighlight>{{out}}
<pre>
The first 50 Pierpont primes (first kind) are: BigInt[2, 3, 5, 7, 13, 17, 19, 37, 73, 97, 109, 163, 193, 257, 433, 487, 577, 769, 1153, 1297, 1459, 2593, 2917, 3457, 3889, 10369, 12289, 17497, 18433, 39367, 52489, 65537, 139969, 147457, 209953, 331777, 472393, 629857, 746497, 786433, 839809, 995329, 1179649, 1492993, 1769473, 1990657, 2654209, 5038849, 5308417, 8503057]
Line 1,550 ⟶ 1,593:
=={{header|Kotlin}}==
{{trans|Go}}
<langsyntaxhighlight lang="scala">import java.math.BigInteger
import kotlin.math.min
 
Line 1,627 ⟶ 1,670:
println("\n2000th Pierpont prime of the first kind: ${p[0][1999]}")
println("\n2000th Pierpont prime of the first kind: ${p[1][1999]}")
}</langsyntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
Line 1,656 ⟶ 1,699:
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">local function isprime(n)
if n < 2 then return false end
if n % 2 == 0 then return n==2 end
Line 1,705 ⟶ 1,748:
for i, p in ipairs(p2) do
io.write(string.format("%8d%s", p, (i%10==0 and "\n" or " ")))
end</langsyntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
Line 1,720 ⟶ 1,763:
62207 73727 131071 139967 165887 294911 314927 442367 472391 497663
524287 786431 995327 1062881 2519423 10616831 17915903 18874367 25509167 30233087</pre>
 
=={{header|M2000 Interpreter}}==
{{trans|freebasic}}
<syntaxhighlight lang="m2000 interpreter">Module Pierpoint_Primes {
Form 80
Set Fast !
const NPP=50
dim pier(1 to 2, 1 to NPP), np(1 to 2) = 0
def long x = 1, j
while np(1)<=NPP or np(2)<=NPP
x++
j = @is_pierpont(x)
if j>0 Else Continue
if j mod 2 = 1 then np(1)++ :if np(1) <= NPP then pier(1, np(1)) = x
if j > 1 then np(2)++ : if np(2) <= NPP then pier(2, np(2)) = x
end while
print "First ";NPP;" Pierpont primes of the first kind:"
for j = 1 to NPP
print pier(2, j),
next j
if pos>0 then print
print "First ";NPP;" Pierpont primes of the second kind:"
for j = 1 to NPP
print pier(1, j),
next j
if pos>0 then print
Set Fast
function is_prime(n as decimal)
if n < 2 then = false : exit function
if n <4 then = true : exit function
if n mod 2 = 0 then = false : exit function
local i as long
for i = 3 to int(sqrt(n))+1 step 2
if n mod i = 0 then = false : exit function
next i
= true
end function
function is_23(n as long)
while n mod 2 = 0
n = n div 2
end while
while n mod 3 = 0
n = n div 3
end while
if n = 1 then = true else = false
end function
function is_pierpont(n as long)
if not @is_prime(n) then = 0& : exit function 'not prime
Local p1 = @is_23(n+1), p2 = @is_23(n-1)
if p1 and p2 then = 3 : exit function 'pierpont prime of both kinds
if p1 then = 1 : exit function 'pierpont prime of the 1st kind
if p2 then = 2 : exit function 'pierpont prime of the 2nd kind
= 0 'prime, but not pierpont
end function
}
Pierpoint_Primes</syntaxhighlight>
 
{{out}}
<pre>
First 50 Pierpont primes of the first kind:
2 3 5 7 13 17 19 37 73 97
109 163 193 257 433 487 577 769 1153 1297
1459 2593 2917 3457 3889 10369 12289 17497 18433 39367
52489 65537 139969 147457 209953 331777 472393 629857 746497 786433
839809 995329 1179649 1492993 1769473 1990657 2654209 5038849 5308417 8503057
 
First 50 Pierpont primes of the second kind:
2 3 5 7 11 17 23 31 47 53
71 107 127 191 383 431 647 863 971 1151
2591 4373 6143 6911 8191 8747 13121 15551 23327 27647
62207 73727 131071 139967 165887 294911 314927 442367 472391 497663
524287 786431 995327 1062881 2519423 10616831 17915903 18874367 25509167 30233087
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">ClearAll[FindUpToMax]
FindUpToMax[max_Integer, b_Integer] := Module[{res, num},
res = {};
Line 1,748 ⟶ 1,867:
Part[FindUpToMax[10^130, +1], 1000]
Print["1000th Piermont prime of the second kind:"]
Part[FindUpToMax[10^150, -1], 1000]</langsyntaxhighlight>
{{out}}
<pre>Piermont primes of the first kind:
Line 1,765 ⟶ 1,884:
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import math, strutils
 
func isPrime(n: int): bool =
Line 1,821 ⟶ 1,940:
stdout.write ($n).align(9)
inc count
if count mod 10 == 0: stdout.write '\n'</langsyntaxhighlight>
 
{{out}}
Line 1,841 ⟶ 1,960:
{{trans|Raku}}
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,893 ⟶ 2,012:
 
say "\n250th Pierpont prime of the first kind: " . $pierpont_1st[249];
say "\n250th Pierpont prime of the second kind: " . $pierpont_2nd[249];</langsyntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
Line 1,917 ⟶ 2,036:
{{trans|Go}}
I also tried using a priority queue, popping the smallest (and any duplicates of it) and pushing *2 and *3 on every iteration, which worked pretty well but ended up about 20% slower, with about 1500 untested candidates left in the queue by the time it found the 2000th second kind.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo/rosetta/Pierpont_primes.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
Line 1,985 ⟶ 2,104:
<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;">"Took %s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,015 ⟶ 2,134:
 
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">
<lang Prolog>
?- use_module(library(heaps)).
 
Line 2,104 ⟶ 2,223:
 
?- main.
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 2,115 ⟶ 2,234:
=={{header|Python}}==
{{trans|Go}}
<langsyntaxhighlight lang="python">import random
 
# Copied from https://rosettacode.org/wiki/Miller-Rabin_primality_test#Python
Line 2,192 ⟶ 2,311:
print "250th Pierpont prime of the second kind:", pp2[249]
 
main()</langsyntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
Line 2,208 ⟶ 2,327:
250th Pierpont prime of the first kind: 62518864539857068333550694039553
250th Pierpont prime of the second kind: 4111131172000956525894875083702271</pre>
 
=={{header|Quackery}}==
 
Uses <code>smoothwith</code> from [[N-smooth numbers#Quackery]] and <code>isprime</code> from [[Primality by trial division#Quackery]].
 
Using trial division to determine primality makes finding the 250th Pierpont primes impractical. This should be updated when a coding of a more suitable test becomes available.
 
<syntaxhighlight lang="quackery"> [ stack ] is pierponts
[ stack ] is kind
[ stack ] is quantity
 
[ 1 - -2 * 1+ kind put
1+ quantity put
' [ -1 ] pierponts put
' [ 2 3 ] smoothwith
[ -1 peek
kind share +
dup isprime not iff
[ drop false ] done
pierponts share -1 peek
over = iff
[ drop false ] done
pierponts take
swap join
dup size swap
pierponts put
quantity share = ]
drop
quantity release
kind release
pierponts take
behead drop ] is pierpontprimes
 
say "Pierpont primes of the first kind." cr
50 1 pierpontprimes echo
cr cr
say "Pierpont primes of the second kind." cr
50 2 pierpontprimes echo</syntaxhighlight>
 
{{out}}
 
<pre>Pierpont primes of the first kind.
[ 2 3 5 7 13 17 19 37 73 97 109 163 193 257 433 487 577 769 1153 1297 1459 2593 2917 3457 3889 10369 12289 17497 18433 39367 52489 65537 139969 147457 209953 331777 472393 629857 746497 786433 839809 995329 1179649 1492993 1769473 1990657 2654209 5038849 5308417 8503057 ]
 
Pierpont primes of the second kind.
[ 2 3 5 7 11 17 23 31 47 53 71 107 127 191 383 431 647 863 971 1151 2591 4373 6143 6911 8191 8747 13121 15551 23327 27647 62207 73727 131071 139967 165887 294911 314927 442367 472391 497663 524287 786431 995327 1062881 2519423 10616831 17915903 18874367 25509167 30233087 ]</pre>
 
=={{header|Raku}}==
Line 2,219 ⟶ 2,384:
an overabundance. No need to rely on magic numbers. No need to sort them. It
produces exactly what is needed, in order, on demand.
{{libheader|ntheory}}
 
<syntaxhighlight lang="raku" perl6line>use ntheory:from<Perl5> <is_prime>;
 
sub pierpont ($kind is copy = 1) {
Line 2,253 ⟶ 2,418:
say "\n250th Pierpont prime of the first kind: " ~ pierpont[249];
 
say "\n250th Pierpont prime of the second kind: " ~ pierpont(2)[249];</langsyntaxhighlight>
 
{{out}}
Line 2,279 ⟶ 2,444:
(Cut down output as it is exactly the same as the first version for {2,3} +1 and {2,3} -1; leaves room to demo some other options.)
 
<syntaxhighlight lang="raku" perl6line>sub smooth-numbers (*@list) {
cache my \Smooth := gather {
my %i = (flat @list) Z=> (Smooth.iterator for ^@list);
Line 2,307 ⟶ 2,472:
"\nOEIS: A077314:", (2,7), -1, 20,
"\nOEIS: A174144 - (\"Humble\" primes 1st):", (2,3,5,7), 1, 20,
"\nOEIS: A299171A347977 - (\"Humble\" primes 2nd):", (2,3,5,7), -1, 20,
"\nOEIS: A077499:", (2,11), 1, 20,
"\nOEIS: A077315:", (2,11), -1, 20,
Line 2,317 ⟶ 2,482:
say "$title smooth \{$primes\} {$add > 0 ?? '+' !! '-'} 1 ";
put smooth-numbers(|$primes).map( * + $add ).grep( *.is-prime )[^$count]
}</langsyntaxhighlight>
 
{{Out}}
Line 2,371 ⟶ 2,536:
The REXX language has a "big num" capability to handle almost any amount of decimal digits, &nbsp; but
<br>it lacks a robust &nbsp; '''isPrime''' &nbsp; function. &nbsp; Without that, verifying very large primes is problematic.
<langsyntaxhighlight lang="rexx">/*REXX program finds and displays Pierpont primes of the first and second kinds. */
parse arg n . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n= 50 /*Not specified? Then use the default.*/
Line 2,406 ⟶ 2,571:
_= pu*pv + t; if _ >s then m= min(_, m)
end /*jv*/
end /*ju*/ /*see the RETURN (above). */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 2,425 ⟶ 2,590:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 2,482 ⟶ 2,647:
 
see "done2..." + nl
</syntaxhighlight>
</lang>
Output:
<pre>
Line 2,594 ⟶ 2,759:
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'gmp'
 
def smooth_generator(ar)
return to_enum(__method__, ar) unless block_given?
next_smooth = 1
queues = ar.map{|num| [num, []] }
loop do
yield next_smooth
queues.each {|m, queue| queue << next_smooth * m}
next_smooth = queues.collect{|m, queue| queue.first}.min
queues.each{|m, queue| queue.shift if queue.first == next_smooth }
end
end
def pierpont(num = 1)
return to_enum(__method__, num) unless block_given?
smooth_generator([2,3]).each{|smooth| yield smooth+num if GMP::Z(smooth + num).probab_prime? > 0}
end
 
def puts_cols(ar, n=10)
ar.each_slice(n).map{|slice|puts slice.map{|n| n.to_s.rjust(10)}.join }
end
 
n, m = 50, 250
puts "First #{n} Pierpont primes of the first kind:"
puts_cols(pierpont.take(n))
puts "#{m}th Pierpont prime of the first kind: #{pierpont.take(250).last}",""
puts "First #{n} Pierpont primes of the second kind:"
puts_cols(pierpont(-1).take(n))
puts "#{m}th Pierpont prime of the second kind: #{pierpont(-1).take(250).last}"
</syntaxhighlight>
{{out}}
<pre>First 50 Pierpont primes of the first kind:
2 3 5 7 13 17 19 37 73 97
109 163 193 257 433 487 577 769 1153 1297
1459 2593 2917 3457 3889 10369 12289 17497 18433 39367
52489 65537 139969 147457 209953 331777 472393 629857 746497 786433
839809 995329 1179649 1492993 1769473 1990657 2654209 5038849 5308417 8503057
250th Pierpont prime of the first kind: 62518864539857068333550694039553
 
First 50 Pierpont primes of the second kind:
2 3 5 7 11 17 23 31 47 53
71 107 127 191 383 431 647 863 971 1151
2591 4373 6143 6911 8191 8747 13121 15551 23327 27647
62207 73727 131071 139967 165887 294911 314927 442367 472391 497663
524287 786431 995327 1062881 2519423 10616831 17915903 18874367 25509167 30233087
250th Pierpont prime of the second kind: 4111131172000956525894875083702271
</pre>
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func smooth_generator(primes) {
var s = primes.len.of { [1] }
{
Line 2,623 ⟶ 2,837:
say "\n#{n}th Pierpont prime of the 1st kind: #{p}"
say "#{n}th Pierpont prime of the 2nd kind: #{q}"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 2,641 ⟶ 2,855:
1000th Pierpont prime of the 2nd kind: 1308088756227965581249669045506775407896673213729433892383353027814827286537163695213418982500477392209371001259166465228280492460735463423
</pre>
 
=={{header|Swift}}==
 
3-smooth version.
 
Using AttaSwift's BigInt library.
 
<syntaxhighlight lang="swift">import BigInt
import Foundation
 
public func pierpoint(n: Int) -> (first: [BigInt], second: [BigInt]) {
var primes = (first: [BigInt](repeating: 0, count: n), second: [BigInt](repeating: 0, count: n))
 
primes.first[0] = 2
 
var count1 = 1, count2 = 0
var s = [BigInt(1)]
var i2 = 0, i3 = 0, k = 1
var n2 = BigInt(0), n3 = BigInt(0), t = BigInt(0)
 
while min(count1, count2) < n {
n2 = s[i2] * 2
n3 = s[i3] * 3
 
if n2 < n3 {
t = n2
i2 += 1
} else {
t = n3
i3 += 1
}
 
if t <= s[k - 1] {
continue
}
 
s.append(t)
k += 1
t += 1
 
if count1 < n && t.isPrime(rounds: 10) {
primes.first[count1] = t
count1 += 1
}
 
t -= 2
 
if count2 < n && t.isPrime(rounds: 10) {
primes.second[count2] = t
count2 += 1
}
}
 
return primes
}
 
 
let primes = pierpoint(n: 250)
 
print("First 50 Pierpoint primes of the first kind: \(Array(primes.first.prefix(50)))\n")
print("First 50 Pierpoint primes of the second kind: \(Array(primes.second.prefix(50)))")
print()
print("250th Pierpoint prime of the first kind: \(primes.first[249])")
print("250th Pierpoint prime of the second kind: \(primes.second[249])")</syntaxhighlight>
 
{{out}}
 
<pre>First 50 Pierpoint primes of the first kind: [2, 3, 5, 7, 13, 17, 19, 37, 73, 97, 109, 163, 193, 257, 433, 487, 577, 769, 1153, 1297, 1459, 2593, 2917, 3457, 3889, 10369, 12289, 17497, 18433, 39367, 52489, 65537, 139969, 147457, 209953, 331777, 472393, 629857, 746497, 786433, 839809, 995329, 1179649, 1492993, 1769473, 1990657, 2654209, 5038849, 5308417, 8503057]
 
First 50 Pierpoint primes of the second kind: [2, 3, 5, 7, 11, 17, 23, 31, 47, 53, 71, 107, 127, 191, 383, 431, 647, 863, 971, 1151, 2591, 4373, 6143, 6911, 8191, 8747, 13121, 15551, 23327, 27647, 62207, 73727, 131071, 139967, 165887, 294911, 314927, 442367, 472391, 497663, 524287, 786431, 995327, 1062881, 2519423, 10616831, 17915903, 18874367, 25509167, 30233087]
 
250th Pierpoint prime of the first kind: 62518864539857068333550694039553
250th Pierpoint prime of the second kind: 4111131172000956525894875083702271</pre>
 
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-big}}
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
The 3-smooth version. Just the first 250 - a tolerable 14 seconds or so on my machine.
<langsyntaxhighlight ecmascriptlang="wren">import "./big" for BigInt
import "./mathfmt" for MathFmt
import "/fmt" for Fmt
 
var pierpont = Fn.new { |n, first|
Line 2,690 ⟶ 2,975:
count2 = count2 + 1
}
count = Mathcount1.min(count1, count2)
}
}
Line 2,696 ⟶ 2,981:
}
 
var start = System.clock
var p = pierpont.call(250, true)
System.print("First 50 Pierpont primes of the first kind:")
Line 2,710 ⟶ 2,994:
 
System.print("\n250th Pierpont prime of the first kind: %(p[0][249])")
System.print("\n250th Pierpont prime of the second kind: %(p[1][249])")</syntaxhighlight>
System.print("Took %(System.clock - start)")</lang>
 
{{out}}
Line 2,732 ⟶ 3,015:
 
250th Pierpont prime of the second kind: 4111131172000956525894875083702271
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func IsPrime(N); \Return 'true' if N is prime
int N, D;
[if N < 2 then return false;
if (N&1) = 0 then return N = 2;
if rem(N/3) = 0 then return N = 3;
D:= 5;
while D*D <= N do
[if rem(N/D) = 0 then return false;
D:= D+2;
if rem(N/D) = 0 then return false;
D:= D+4;
];
return true;
];
 
func Pierpont(N); \Return 'true' if N is a multiple of 2^U*3^V
int N;
[while (N&1) = 0 do N:= N>>1;
while N>1 do
[N:= N/3;
if rem(0) # 0 then return false;
];
return true;
];
 
int Kind, N, Count;
[Format(9, 0);
Kind:= 1;
repeat Count:= 0; N:= 2;
loop [if IsPrime(N) then
[if Pierpont(N-Kind) then
[Count:= Count+1;
RlOut(0, float(N));
if rem(Count/10) = 0 then CrLf(0);
if Count >= 50 then quit;
];
];
N:= N+1;
];
CrLf(0);
Kind:= -Kind;
until Kind = 1;
]</syntaxhighlight>
{{out}}
<pre>
2 3 5 7 13 17 19 37 73 97
109 163 193 257 433 487 577 769 1153 1297
1459 2593 2917 3457 3889 10369 12289 17497 18433 39367
52489 65537 139969 147457 209953 331777 472393 629857 746497 786433
839809 995329 1179649 1492993 1769473 1990657 2654209 5038849 5308417 8503057
 
2 3 5 7 11 17 23 31 47 53
71 107 127 191 383 431 647 863 971 1151
2591 4373 6143 6911 8191 8747 13121 15551 23327 27647
62207 73727 131071 139967 165887 294911 314927 442367 472391 497663
524287 786431 995327 1062881 2519423 10616831 17915903 18874367 25509167 30233087
 
</pre>
 
Line 2,738 ⟶ 3,081:
{{libheader|GMP}} GNU Multiple Precision Arithmetic Library
Using GMP's probabilistic primes makes it is easy and fast to test for primeness.
<langsyntaxhighlight lang="zkl">var [const] BI=Import("zklBigNum"); // libGMP
var [const] one=BI(1), two=BI(2), three=BI(3);
 
Line 2,766 ⟶ 3,109:
}
return(pps1,pps2)
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">pps1,pps2 := pierPonts(2_000);
 
println("The first 50 Pierpont primes (first kind):");
Line 2,778 ⟶ 3,121:
println("\n%4dth Pierpont prime, first kind: ".fmt(n), pps1[n-1]);
println( " second kind: ", pps2[n-1]);
}</langsyntaxhighlight>
{{out}}
<pre style="font-size:83%">
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/293029...353893"