Wieferich primes: Difference between revisions

=={{header|Ada}}==

{{trans|BASIC256}}

procedure Wieferich_Primes is

end loop;

{{out}}

<pre>

=={{header|APL}}==

'''Works in:''' [[Dyalog APL]]

⍝ pco ← prime finder

⍝ nats ← natural number arithmetic (uses strings)

wief 5000

1093 3511

=={{header|Arturo}}==

and? -> prime? n

-> zero? (dec 2 ^ n-1) % n ^ 2

]

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f WIEFERICH_PRIMES.AWK

# converted from FreeBASIC

return(q == 1)

}

{{out}}

<pre>

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

{{trans|FreeBASIC}}

for i = 1 to 5000

if isWeiferich(i) then print i

end while

return True

{{out}}

<pre>Igual que la entrada de FreeBASIC.</pre>

==={{header|PureBasic}}===

{{trans|FreeBASIC}}

Protected k

Next i

Input()

{{out}}

<pre>Igual que la entrada de FreeBASIC.</pre>

==={{header|Run BASIC}}===

for i = 1 to 5000

if isWeiferich(i) then print i

end if

[exit]

{{out}}

<pre>Igual que la entrada de FreeBASIC.</pre>

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

{{trans|FreeBASIC}}

for i = 2 to 5000

if isWeiferich(i) print i

wend

return True

{{out}}

<pre>Igual que la entrada de FreeBASIC.</pre>

=={{header|C}}==

{{trans|C++}}

#include <stdio.h>

#include <stdint.h>

return 0;

{{out}}

<pre>Wieferich primes less than 5000:

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

#include <iostream>

#include <vector>

for (uint64_t p : wieferich_primes(limit))

std::cout << p << '\n';

{{out}}

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

{{trans|Java}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>Wieferich primes less that 5000:

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

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

// Weiferich primes: Nigel Galloway. June 2nd., 2021

primes32()|>Seq.takeWhile((>)5000)|>Seq.filter(fun n->(2I**(n-1)-1I)%(bigint(n*n))=0I)|>Seq.iter(printfn "%d")

{{out}}

<pre>

=={{header|Factor}}==

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

sequences ;

"Wieferich primes less than 5000:" print

{{out}}

<pre>

=={{header|fermat}}==

Func Iswief(p)=Isprime(p)*Divides(p^2, 2^(p-1)-1).

for i=2 to 5000 do if Iswief(i) then !!i fi od

{{out}}<pre>

1093

=={{header|Forth}}==

{{works with|Gforth}}

: notprime! ( n -- ) here + 1 swap c! ;

5000 wieferich_primes

{{out}}

=={{header|FreeBASIC}}==

#include "isprime.bas"

for i as uinteger = 1 to 5000

if iswief(i) then print i

=={{header|Go}}==

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

}

}

{{out}}

=={{header|Haskell}}==

isPrime n

|n == 2 = True

main = do

putStrLn "Wieferich primes less than 5000:"

{{out}}

<pre>Wieferich primes less than 5000:

=={{header|J}}==

About 12 times faster:

=={{header|Java}}==

{{trans|C++}}

public class WieferichPrimes {

return result;

}

{{out}}

gojq supports unbounded-precision integer arithmetic and so is up to this task.

. as $n

| if ($n < 2) then false

# for the sake of infinite-precision integer arithmetic

def power($b): . as $a | reduce range(0; $b) as $i (1; .*$a);

'''The task'''

def wieferich:

primes[]

5000 | wieferich

{{out}}

<pre>

=={{header|Julia}}==

println(filter(p -> (big"2"^(p - 1) - 1) % p^2 == 0, primes(5000))) # [1093, 3511]

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

WieferichPrimeQ[n_Integer] := PrimeQ[n] && Divisible[2^(n - 1) - 1, n^2]

{{out}}

<pre>{1093, 3511}</pre>

=={{header|Nim}}==

{{libheader|bignum}}

import bignum

if p.isPrime:

if exp(two, p - 1, p * p) == 1: # Modular exponentiation.

{{out}}

=={{header|PARI/GP}}==

{{out}}<pre>1093

3511</pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use ntheory qw(is_prime powmod);

{{out}}

<pre>Wieferich primes less than 5000: 1093, 3511</pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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: #008080;">end</span> <span style="color: #008080;">function</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;">"Weiferich primes less than 5000: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5000</span><span style="color: #0000FF;">),</span><span style="color: #000000;">weiferich</span><span style="color: #0000FF;">)})</span>

{{out}}

</pre>

alternative (same results), should be significantly faster, in the (largely pointless!) hunt for larger numbers.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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: #008080;">end</span> <span style="color: #008080;">function</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;">"Weiferich primes less than 5000: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5000</span><span style="color: #0000FF;">),</span><span style="color: #000000;">weiferich</span><span style="color: #0000FF;">)})</span>

=={{header|PicoLisp}}==

(let M 1

(loop

(=1 (**Mod 2 (dec D) (* D D)))

(println D) )

{{out}}

<pre>

=={{header|Python}}==

def isPrime(n):

for i in range(2, 5001):

if isWeiferich(i):

{{out}}

<pre>Wieferich primes less than 5000:

<code>eratosthenes</code> and <code>isprime</code> are defined at [[Sieve of Eratosthenes#Quackery]].

[ dup isprime iff

else [ drop false ] ] is wieferich ( n --> b )

{{out}}

=={{header|Racket}}==

(require math/number-theory)

p))

wieferich-primes<5000)

{{out}}

=={{header|Raku}}==

{{out}}

<pre>Wieferich primes less than 5000: 1093, 3511</pre>

=={{header|REXX}}==

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

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

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

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

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

<pre>

=={{header|Ruby}}==

puts Prime.each(5000).select{|p| 2.pow(p-1 ,p*p) == 1 }

{{out}}

<pre>1093

=={{header|Rust}}==

// primal = "0.3"

// mod_exp = "1.0"

println!("{}", p);

}

{{out}}

=={{header|Sidef}}==

powmod(base, p-1, p**2) == 1

}

{{out}}

<pre>

=={{header|Swift}}==

{{trans|C++}}

guard limit > 0 else {

return []

for p in wieferichPrimes(limit: limit) {

print(p)

{{out}}

{{libheader|Wren-math}}

{{libheader|Wren-big}}

import "/big" for BigInt

var den = p * p

if (num % den == 0) System.print(p)

{{out}}