Wilson primes of order n: Difference between revisions

Algol 68G supports long integers, however the precision must be specified.<br>

As the memory required for a limit of 11 000 would exceed he maximum supported by Algol 68G under WIndows, a limit of 5 500 is used here, which is sufficient to find all but the 4th order Wilson prime.

# ( ( n - 1 )! x ( p - n )! - (-1)^n ) mod p^2 = 0 #

INT limit = 5 508; # max prime to consider #

print( ( newline ) )

OD

{{out}}

<pre>

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

if v <= 1 then return False

for i = 2 To int(sqr(v))

print

next n

==={{header|QBasic}}===

{{works with|QuickBasic}}

{{trans|FreeBASIC}}

IF ValorEval < 2 THEN isPrime = False

IF ValorEval MOD 2 = 0 THEN isPrime = 2

PRINT

NEXT n

==={{header|Yabasic}}===

{{trans|FreeBASIC}}

print "---------------------"

for n = 1 to 11

prod = mod((p2 + prod - (-1)**n), p2)

if prod = 0 then return True else return False : fi

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

{{libheader|GMP}}

#include <iostream>

#include <vector>

std::cout << '\n';

}

{{out}}

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

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]

// Wilson primes. Nigel Galloway: July 31st., 2021

let rec fN g=function n when n<2I->g |n->fN(n*g)(n-1I)

let fG (n:int)(p:int)=let g,p=bigint n,bigint p in (((fN 1I (g-1I))*(fN 1I (p-g))-(-1I)**n)%(p*p))=0I

[1..11]|>List.iter(fun n->printf "%2d -> " n; let fG=fG n in pCache|>Seq.skipWhile((>)n)|>Seq.takeWhile((>)11000)|>Seq.filter fG|>Seq.iter(printf "%d "); printfn "")

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-06-02}}

math.primes math.ranges prettyprint sequences sequences.extras ;

" n: Wilson primes\n--------------------" print

{{out}}

<pre>

=={{header|FreeBASIC}}==

This excludes the trivial case p=n=2.

function is_wilson( n as uinteger, p as uinteger ) as boolean

print

next n

{{out}}<pre>

n: Wilson primes

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

fmt.Println()

}

{{out}}

=={{header|GW-BASIC}}==

20 PRINT "--------------------"

30 FOR N = 1 TO 11

3000 REM PROD# MOD P2 fails if PROD#>32767 so brew our own modulus function

3010 PROD# = PROD# - INT(PROD#/P2)*P2

=={{header|Java}}==

import java.util.*;

return primes;

}

{{out}}

'''Preliminaries'''

# For 0 <= $n <= ., factorials[$n] is $n !

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

'''Wilson primes'''

def wilson_primes:

def sgn: if . % 2 == 0 then 1 else -1 end;

% ($p*$p) == 0 )) ])" );

{{out}}

gojq -ncr -f rc-wilson-primes.jq

=={{header|Julia}}==

{{trans|Wren}}

function wilsonprimes(limit = 11000)

wilsonprimes()

Output: Same as Wren example.

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

WilsonPrime[n_Integer] := Module[{primes, out},

primes = Prime[Range[PrimePi[11000]]];

,

{n, 1, 11}

{{out}}

<pre>{5,13,563}

{{libheader|bignum}}

As in Nim there is not (not yet?) a standard module to deal with big numbers, we use the third party module “bignum”.

import bignum

if f mod (p * p) == 0:

wilson.add p

{{out}}

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use ntheory <primes factorial>;

for my $n (1..11) {

printf "%3d: %s\n", $n, join ' ', grep { $_ >= $n && 0 == (factorial($n-1) * factorial($_-$n) - (-1)**$n) % $_**2 } @primes

{{out}}

<pre> 1: 5 13 563

=={{header|Phix}}==

{{trans|Wren}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">11000</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

Output: Same as Wren example.

=={{header|Prolog}}==

{{works with|SWI Prolog}}

wilson_primes(11000).

M1 is M + 1,

F1 is F * M1,

Module for finding prime numbers up to some limit:

:- dynamic is_prime/1.

cross_out(S, N, P):-

Q is S + 2 * P,

{{out}}

=={{header|Racket}}==

(require math/number-theory)

(for ((n (in-range 1 (add1 11))))

{{out}}

=={{header|Raku}}==

sub postfix:<!> (Int $n) { (constant f = 1, |[\×] 1..*)[$n] }

.say for (1..40).hyper(:1batch).map: -> \𝒏 {

sprintf "%3d: %s", 𝒏, @primes.grep( -> \𝒑 { (𝒑 ≥ 𝒏) && ((𝒏 - 1)!⁢(𝒑 - 𝒏)! - (-1) ** 𝒏) %% 𝒑² } ).Str

{{out}}

<pre> n: Wilson primes

=={{header|REXX}}==

For more (extended) results, &nbsp; see this task's discussion page.

/*────────────────── (n-1)! * (P-n)! - (-1)**n where n is 1 ──◄ 11, and P < 18.*/

parse arg oLO oHI hip . /*obtain optional argument from the CL.*/

end /*k*/ /* [↑] only process numbers ≤ √ J */

#= #+1; @.#= j; sq.#= j*j; !.j= 1 /*bump # of Ps; assign next P; P²; P# */

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

<pre>

=={{header|Ruby}}==

module Modulo

puts "#{n.to_s.rjust(2)}: #{res.inspect}"

end

{{out}}

<pre> 1: [5, 13, 563]

</pre>

=={{header|Rust}}==

// rug = "1.13.0"

s = -s;

}

{{out}}

=={{header|Sidef}}==

var m = p*p

(factorialmod(n-1, m) * factorialmod(p-n, m) - (-1)**n) % m == 0

for n in (1..11) {

printf("%3d: %s\n", n, primes.grep {|p| is_wilson_prime(p, n) })

{{out}}

<pre>

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

import "/big" for BigInt

import "/fmt" for Fmt

}

System.print()

{{out}}