Pierpont primes: Difference between revisions

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

# and second kind (2^u3^v - 1) #

# construct a sieve of primes up to 10 000 #

print pierpoint( pfirst, "First" );

print pierpoint( psecond, "Second" )

{{out}}

<pre>

=={{header|C}}==

{{trans|D}}

#include <stdint.h>

#include <stdio.h>

}

printf("\n");

{{out}}

<pre>First 50 Pierpont primes of the first kind:

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.Numerics;

}

}

{{out}}

<pre>First 50 Pierpont primes of the first kind:

=={{header|C++}}==

{{libheader|GMP}}

#include <algorithm>

#include <iomanip>

std::cout << "250th Pierpont prime of the second kind: " << p2 << '\n';

return 0;

 

{{out}}

=={{header|D}}==

{{trans|C#}}

import std.bigint;

import std.random;

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]);

{{out}}

<pre>First 50 Pierpont primes of the first kind:

{{Trans|Go}}

Thanks Rudy Velthuis for the [https://github.com/rvelthuis/DelphiBigNumbers Velthuis.BigIntegers.Primes and Velthuis.BigIntegers] library.<br>

program Pierpont_primes;

 

 

readln;

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

This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>

// Pierpont primes . Nigel Galloway: March 19th., 2021

let fN g=let mutable g=g in ((fun()->g),fun()->g<-g+g;())

pierpontT1|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""

pierpontT2|>Seq.take 50|>Seq.iter(printf "%d "); printfn ""

{{out}}

<pre>

</pre>

=={{header|Factor}}==

math.primes prettyprint sequences sorting ;

 

"250th Pierpont prime of the second kind: " write

249 second nth .

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

 

Function isPrime(Byval n As Ulongint) As Boolean

If j Mod 10 = 0 Then Print

Next j

{{out}}

<pre>

 

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.

 

import (

fmt.Println("\n250th Pierpont prime of the first kind:", pp[249])

fmt.Println("\n250th Pierpont prime of the second kind:", pp2[249])

 

{{out}}

These timings are for my Celeron @1.6GHz and should therefore be much faster on a more modern machine.

 

 

import (

elapsed := time.Now().Sub(start)

fmt.Printf("\nTook %s\n", elapsed)

 

{{out}}

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

import Data.List (intercalate)

import Data.List.Split (chunksOf)

where

rows = chunksOf 10 . take 50

{{out}}

<pre>

Implementation (first kind first):

 

2 3 5 7 13 17 19 37 73 97

109 163 193 257 433 487 577 769 1153 1297

2591 4373 6143 6911 8191 8747 13121 15551 23327 27647

62207 73727 131071 139967 165887 294911 314927 442367 472391 497663

 

and

 

62518864539857068333550694039553

249{ (#~ 1 p:])_1+/:~,*//2 3x^/i.112

 

=={{header|Java}}==

import java.math.BigInteger;

import java.text.NumberFormat;

}

 

{{out}}

 

'''Preliminaries'''

. as $n

| if ($n < 2) then false

 

def table($ncols; $colwidth):

'''Pierpont primes'''

# 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),

50

| "\nThe first \(.) Pierpoint primes of the first kind:", (pierponts(true) | table(10;8)),

{{out}}

<pre>

=={{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.

 

function pierponts(N, firstkind = true)

 

println("\nThe 2000th Pierpont prime (second kind) is: ", pierponts(2000, false)[2000])

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

=={{header|Kotlin}}==

{{trans|Go}}

import kotlin.math.min

 

println("\n2000th Pierpont prime of the first kind: ${p[0][1999]}")

println("\n2000th Pierpont prime of the first kind: ${p[1][1999]}")

{{out}}

<pre>First 50 Pierpont primes of the first kind:

 

=={{header|Lua}}==

if n < 2 then return false end

if n % 2 == 0 then return n==2 end

for i, p in ipairs(p2) do

io.write(string.format("%8d%s", p, (i%10==0 and "\n" or " ")))

{{out}}

<pre>First 50 Pierpont primes of the first kind:

=={{header|M2000 Interpreter}}==

{{trans|freebasic}}

Form 80

Set Fast !

end function

}

 

{{out}}

 

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

FindUpToMax[max_Integer, b_Integer] := Module[{res, num},

res = {};

Part[FindUpToMax[10^130, +1], 1000]

Print["1000th Piermont prime of the second kind:"]

{{out}}

<pre>Piermont primes of the first kind:

 

=={{header|Nim}}==

 

func isPrime(n: int): bool =

stdout.write ($n).align(9)

inc count

 

{{out}}

{{trans|Raku}}

{{libheader|ntheory}}

use warnings;

use feature 'say';

 

say "\n250th Pierpont prime of the first kind: " . $pierpont_1st[249];

{{out}}

<pre>First 50 Pierpont primes of the first kind:

{{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.

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

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

{{out}}

<pre>

 

=={{header|Prolog}}==

?- use_module(library(heaps)).

 

 

?- main.

{{Out}}

<pre>

=={{header|Python}}==

{{trans|Go}}

 

# Copied from https://rosettacode.org/wiki/Miller-Rabin_primality_test#Python

print "250th Pierpont prime of the second kind:", pp2[249]

 

{{out}}

<pre>First 50 Pierpont primes of the first kind:

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.

 

[ stack ] is kind

[ stack ] is quantity

cr cr

say "Pierpont primes of the second kind." cr

 

{{out}}

produces exactly what is needed, in order, on demand.

{{libheader|ntheory}}

 

sub pierpont ($kind is copy = 1) {

say "\n250th Pierpont prime of the first kind: " ~ pierpont[249];

 

 

{{out}}

(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.)

 

cache my \Smooth := gather {

my %i = (flat @list) Z=> (Smooth.iterator for ^@list);

say "$title smooth \{$primes\} {$add > 0 ?? '+' !! '-'} 1 ";

put smooth-numbers(|$primes).map( * + $add ).grep( *.is-prime )[^$count]

 

{{Out}}

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.

parse arg n . /*obtain optional argument from the CL.*/

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

_= pu*pv + t; if _ >s then m= min(_, m)

end /*jv*/

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

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

 

see "done2..." + nl

Output:

<pre>

 

=={{header|Ruby}}==

 

def smooth_generator(ar)

puts_cols(pierpont(-1).take(n))

puts "#{m}th Pierpont prime of the second kind: #{pierpont(-1).take(250).last}"

{{out}}

<pre>First 50 Pierpont primes of the first kind:

</pre>

=={{header|Sidef}}==

var s = primes.len.of { [1] }

{

say "\n#{n}th Pierpont prime of the 1st kind: #{p}"

say "#{n}th Pierpont prime of the 2nd kind: #{q}"

{{out}}

<pre>

Using AttaSwift's BigInt library.

 

import Foundation

 

print()

print("250th Pierpoint prime of the first kind: \(primes.first[249])")

 

{{out}}

{{libheader|Wren-fmt}}

The 3-smooth version. Just the first 250 - a tolerable 14 seconds or so on my machine.

import "/fmt" for Fmt

 

 

System.print("\n250th Pierpont prime of the first kind: %(p[0][249])")

 

{{out}}

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

Using GMP's probabilistic primes makes it is easy and fast to test for primeness.

var [const] one=BI(1), two=BI(2), three=BI(3);

 

}

return(pps1,pps2)

 

println("The first 50 Pierpont primes (first kind):");

println("\n%4dth Pierpont prime, first kind: ".fmt(n), pps1[n-1]);

println( " second kind: ", pps2[n-1]);

{{out}}

<pre style="font-size:83%">