Cullen and Woodall numbers: Difference between revisions
(J) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 44: | Line 44: | ||
Uses Algol 68Gs LONG LONG INT for long integers. The number of digits must be specified and appears to affect the run time as larger sies are specified. This sample only shows the first two Cullen primes as the time taken to find the third is rather long. |
Uses Algol 68Gs LONG LONG INT for long integers. The number of digits must be specified and appears to affect the run time as larger sies are specified. This sample only shows the first two Cullen primes as the time taken to find the third is rather long. |
||
{{libheader|ALGOL 68-primes}} |
{{libheader|ALGOL 68-primes}} |
||
< |
<syntaxhighlight lang="algol68">BEGIN # find Cullen and Woodall numbers and determine which are prime # |
||
# a Cullen number n is n2^2 + 1, Woodall number is n2^n - 1 # |
# a Cullen number n is n2^2 + 1, Woodall number is n2^n - 1 # |
||
PR read "primes.incl.a68" PR # include prime utilities # |
PR read "primes.incl.a68" PR # include prime utilities # |
||
Line 93: | Line 93: | ||
print( ( newline ) ) |
print( ( newline ) ) |
||
END |
END |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 103: | Line 103: | ||
=={{header|Arturo}}== |
=={{header|Arturo}}== |
||
< |
<syntaxhighlight lang="rebol">cullen: function [n]-> |
||
inc n * 2^n |
inc n * 2^n |
||
Line 110: | Line 110: | ||
print ["First 20 cullen numbers:" join.with:" " to [:string] map 1..20 => cullen] |
print ["First 20 cullen numbers:" join.with:" " to [:string] map 1..20 => cullen] |
||
print ["First 20 woodall numbers:" join.with:" " to [:string] map 1..20 => woodall]</ |
print ["First 20 woodall numbers:" join.with:" " to [:string] map 1..20 => woodall]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 118: | Line 118: | ||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
<syntaxhighlight lang="awk"> |
|||
<lang AWK> |
|||
# syntax: GAWK -f CULLEN_AND_WOODALL_NUMBERS.AWK |
# syntax: GAWK -f CULLEN_AND_WOODALL_NUMBERS.AWK |
||
BEGIN { |
BEGIN { |
||
Line 135: | Line 135: | ||
exit(0) |
exit(0) |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 145: | Line 145: | ||
==={{header|BASIC256}}=== |
==={{header|BASIC256}}=== |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
< |
<syntaxhighlight lang="basic256">print "First 20 Cullen numbers:" |
||
for n = 1 to 20 |
for n = 1 to 20 |
||
Line 159: | Line 159: | ||
print int(num); " "; |
print int(num); " "; |
||
next n |
next n |
||
end</ |
end</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 166: | Line 166: | ||
==={{header|FreeBASIC}}=== |
==={{header|FreeBASIC}}=== |
||
< |
<syntaxhighlight lang="freebasic">Dim As Uinteger n, num |
||
Print "First 20 Cullen numbers:" |
Print "First 20 Cullen numbers:" |
||
Line 180: | Line 180: | ||
Print num; " "; |
Print num; " "; |
||
Next n |
Next n |
||
Sleep</ |
Sleep</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>First 20 Cullen numbers: |
<pre>First 20 Cullen numbers: |
||
Line 189: | Line 189: | ||
==={{header|PureBasic}}=== |
==={{header|PureBasic}}=== |
||
< |
<syntaxhighlight lang="purebasic">OpenConsole() |
||
PrintN("First 20 Cullen numbers:") |
PrintN("First 20 Cullen numbers:") |
||
Line 205: | Line 205: | ||
PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input() |
PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input() |
||
CloseConsole()</ |
CloseConsole()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 216: | Line 216: | ||
{{works with|True BASIC}} |
{{works with|True BASIC}} |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
< |
<syntaxhighlight lang="qbasic">DIM num AS LONG ''comment this line for True BASIC |
||
PRINT "First 20 Cullen numbers:" |
PRINT "First 20 Cullen numbers:" |
||
Line 232: | Line 232: | ||
PRINT num; |
PRINT num; |
||
NEXT n |
NEXT n |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 241: | Line 241: | ||
{{works with|QBasic}} |
{{works with|QBasic}} |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
< |
<syntaxhighlight lang="qbasic">REM DIM num AS LONG !uncomment this line for QBasic |
||
PRINT "First 20 Cullen numbers:" |
PRINT "First 20 Cullen numbers:" |
||
Line 257: | Line 257: | ||
PRINT num; |
PRINT num; |
||
NEXT n |
NEXT n |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 264: | Line 264: | ||
==={{header|Yabasic}}=== |
==={{header|Yabasic}}=== |
||
< |
<syntaxhighlight lang="yabasic">print "First 20 Cullen numbers:" |
||
for n = 1 to 20 |
for n = 1 to 20 |
||
Line 278: | Line 278: | ||
next n |
next n |
||
print |
print |
||
end</ |
end</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 286: | Line 286: | ||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp"> |
||
// Cullen and Woodall numbers. Nigel Galloway: January 14th., 2022 |
// Cullen and Woodall numbers. Nigel Galloway: January 14th., 2022 |
||
let Cullen,Woodall=let fG n (g:int)=(bigint g)*2I**g+n in fG 1I, fG -1I |
let Cullen,Woodall=let fG n (g:int)=(bigint g)*2I**g+n in fG 1I, fG -1I |
||
Line 293: | Line 293: | ||
Seq.initInfinite((+)1)|>Seq.filter(fun n->let mutable n=Woodall n in Open.Numeric.Primes.MillerRabin.IsProbablePrime &n)|>Seq.take 12|>Seq.iter(printf "%A "); printfn "" |
Seq.initInfinite((+)1)|>Seq.filter(fun n->let mutable n=Woodall n in Open.Numeric.Primes.MillerRabin.IsProbablePrime &n)|>Seq.take 12|>Seq.iter(printf "%A "); printfn "" |
||
Seq.initInfinite((+)1)|>Seq.filter(fun n->let mutable n=Cullen n in Open.Numeric.Primes.MillerRabin.IsProbablePrime &n)|>Seq.take 5|>Seq.iter(printf "%A "); printfn "" |
Seq.initInfinite((+)1)|>Seq.filter(fun n->let mutable n=Cullen n in Open.Numeric.Primes.MillerRabin.IsProbablePrime &n)|>Seq.take 5|>Seq.iter(printf "%A "); printfn "" |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 304: | Line 304: | ||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
{{works with|Factor|0.99 2022-04-03}} |
{{works with|Factor|0.99 2022-04-03}} |
||
< |
<syntaxhighlight lang="factor">USING: arrays kernel math math.vectors prettyprint ranges |
||
sequences ; |
sequences ; |
||
20 [1..b] [ dup 2^ * 1 + ] map dup 2 v-n 2array simple-table.</ |
20 [1..b] [ dup 2^ * 1 + ] map dup 2 v-n 2array simple-table.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 316: | Line 316: | ||
=={{header|Go}}== |
=={{header|Go}}== |
||
{{libheader|GMP(Go wrapper)}} |
{{libheader|GMP(Go wrapper)}} |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 367: | Line 367: | ||
} |
} |
||
fmt.Println() |
fmt.Println() |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 385: | Line 385: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="haskell">findCullen :: Int -> Integer |
||
findCullen n = toInteger ( n * 2 ^ n + 1 ) |
findCullen n = toInteger ( n * 2 ^ n + 1 ) |
||
Line 399: | Line 399: | ||
print cullens |
print cullens |
||
putStrLn "First 20 Woodall numbers:" |
putStrLn "First 20 Woodall numbers:" |
||
print woodalls</ |
print woodalls</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>First 20 Cullen numbers: |
<pre>First 20 Cullen numbers: |
||
Line 409: | Line 409: | ||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j">cullen=: {{ y* 1+2x^y }} |
||
woodall=: {{ y*_1+2x^y }}</ |
woodall=: {{ y*_1+2x^y }}</syntaxhighlight> |
||
Task example: |
Task example: |
||
< |
<syntaxhighlight lang="j"> cullen 1+i.20 |
||
3 10 27 68 165 390 903 2056 4617 10250 22539 49164 106509 229390 491535 1048592 2228241 4718610 9961491 20971540 |
3 10 27 68 165 390 903 2056 4617 10250 22539 49164 106509 229390 491535 1048592 2228241 4718610 9961491 20971540 |
||
woodall 1+i.20 |
woodall 1+i.20 |
||
1 6 21 60 155 378 889 2040 4599 10230 22517 49140 106483 229362 491505 1048560 2228207 4718574 9961453 20971500</ |
1 6 21 60 155 378 889 2040 4599 10230 22517 49140 106483 229362 491505 1048560 2228207 4718574 9961453 20971500</syntaxhighlight> |
||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
{{trans|Raku}} |
{{trans|Raku}} |
||
< |
<syntaxhighlight lang="julia">using Lazy |
||
using Primes |
using Primes |
||
Line 434: | Line 434: | ||
println("\nFirst 5 Cullen primes: (in terms of n)\n", take(5, primecullens)) # A005849 |
println("\nFirst 5 Cullen primes: (in terms of n)\n", take(5, primecullens)) # A005849 |
||
println("\nFirst 12 Woodall primes: (in terms of n)\n", Int.(collect(take(12, primewoodalls)))) # A002234 |
println("\nFirst 12 Woodall primes: (in terms of n)\n", Int.(collect(take(12, primewoodalls)))) # A002234 |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
First 20 Cullen numbers: ( n × 2**n + 1) |
First 20 Cullen numbers: ( n × 2**n + 1) |
||
Line 449: | Line 449: | ||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
< |
<syntaxhighlight lang="lua">function T(t) return setmetatable(t, {__index=table}) end |
||
table.range = function(t,n) local s=T{} for i=1,n do s[i]=i end return s end |
table.range = function(t,n) local s=T{} for i=1,n do s[i]=i end return s end |
||
table.map = function(t,f) local s=T{} for i=1,#t do s[i]=f(t[i]) end return s end |
table.map = function(t,f) local s=T{} for i=1,#t do s[i]=f(t[i]) end return s end |
||
Line 459: | Line 459: | ||
function woodall(n) return (n<<n)-1 end |
function woodall(n) return (n<<n)-1 end |
||
print("First 20 Woodall numbers:") |
print("First 20 Woodall numbers:") |
||
print(T{}:range(20):map(woodall):concat(" "))</ |
print(T{}:range(20):map(woodall):concat(" "))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>First 20 Cullen numbers: |
<pre>First 20 Cullen numbers: |
||
Line 467: | Line 467: | ||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">ClearAll[CullenNumber, WoodallNumber] |
||
SetAttributes[{CullenNumber, WoodallNumber}, Listable] |
SetAttributes[{CullenNumber, WoodallNumber}, Listable] |
||
CullenNumber[n_Integer] := n 2^n + 1 |
CullenNumber[n_Integer] := n 2^n + 1 |
||
Line 495: | Line 495: | ||
{i, 1, \[Infinity]} |
{i, 1, \[Infinity]} |
||
]; |
]; |
||
wps</ |
wps</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>{3, 9, 25, 65, 161, 385, 897, 2049, 4609, 10241, 22529, 49153, 106497, 229377, 491521, 1048577, 2228225, 4718593, 9961473, 20971521} |
<pre>{3, 9, 25, 65, 161, 385, 897, 2049, 4609, 10241, 22529, 49153, 106497, 229377, 491521, 1048577, 2228225, 4718593, 9961473, 20971521} |
||
Line 504: | Line 504: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
{{libheader|ntheory}} |
{{libheader|ntheory}} |
||
< |
<syntaxhighlight lang="perl">use strict; |
||
use warnings; |
use warnings; |
||
use bigint; |
use bigint; |
||
Line 531: | Line 531: | ||
($m,$n) = (12,0); |
($m,$n) = (12,0); |
||
print "\n\nFirst $m Woodall primes: (in terms of n)\n"; |
print "\n\nFirst $m Woodall primes: (in terms of n)\n"; |
||
print do { $n < $m ? (!!is_prime(cullen $_,-1) and ++$n and "$_ ") : last } for 1 .. Inf;</ |
print do { $n < $m ? (!!is_prime(cullen $_,-1) and ++$n and "$_ ") : last } for 1 .. Inf;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>First 20 Cullen numbers: |
<pre>First 20 Cullen numbers: |
||
Line 546: | Line 546: | ||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
<!--< |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
||
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span> |
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span> |
||
Line 595: | Line 595: | ||
<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 12 Woodall primes (in terms of n):%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">w</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 12 Woodall primes (in terms of n):%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">w</span><span style="color: #0000FF;">)})</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> |
<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> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 607: | Line 607: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python"> |
||
print("working...") |
print("working...") |
||
print("First 20 Cullen numbers:") |
print("First 20 Cullen numbers:") |
||
Line 624: | Line 624: | ||
print() |
print() |
||
print("done...") |
print("done...") |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 636: | Line 636: | ||
===Bit Shift=== |
===Bit Shift=== |
||
{{trans|Quackery}} |
{{trans|Quackery}} |
||
< |
<syntaxhighlight lang="python">def cullen(n): return((n<<n)+1) |
||
def woodall(n): return((n<<n)-1) |
def woodall(n): return((n<<n)-1) |
||
Line 648: | Line 648: | ||
for i in range(1,20): |
for i in range(1,20): |
||
print(woodall(i),end=" ") |
print(woodall(i),end=" ") |
||
print()</ |
print()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 655: | Line 655: | ||
=={{header|Quackery}}== |
=={{header|Quackery}}== |
||
< |
<syntaxhighlight lang="quackery"> [ dup << 1+ ] is cullen ( n --> n ) |
||
[ dup << 1 - ] is woodall ( n --> n ) |
[ dup << 1 - ] is woodall ( n --> n ) |
||
Line 663: | Line 663: | ||
cr |
cr |
||
say "First 20 Woodall numbers:" cr |
say "First 20 Woodall numbers:" cr |
||
20 times [ i^ 1+ woodall echo sp ] cr</ |
20 times [ i^ 1+ woodall echo sp ] cr</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 676: | Line 676: | ||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
<lang |
<syntaxhighlight lang="raku" line>my @cullen = ^∞ .map: { $_ × 1 +< $_ + 1 }; |
||
my @woodall = ^∞ .map: { $_ × 1 +< $_ - 1 }; |
my @woodall = ^∞ .map: { $_ × 1 +< $_ - 1 }; |
||
Line 682: | Line 682: | ||
put "\nFirst 20 Woodall numbers: ( n × 2**n - 1)\n", @woodall[1..20]; # A003261 |
put "\nFirst 20 Woodall numbers: ( n × 2**n - 1)\n", @woodall[1..20]; # A003261 |
||
put "\nFirst 5 Cullen primes: (in terms of n)\n", @cullen.grep( &is-prime, :k )[^5]; # A005849 |
put "\nFirst 5 Cullen primes: (in terms of n)\n", @cullen.grep( &is-prime, :k )[^5]; # A005849 |
||
put "\nFirst 12 Woodall primes: (in terms of n)\n", @woodall.grep( &is-prime, :k )[^12]; # A002234</ |
put "\nFirst 12 Woodall primes: (in terms of n)\n", @woodall.grep( &is-prime, :k )[^12]; # A002234</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>First 20 Cullen numbers: ( n × 2**n + 1) |
<pre>First 20 Cullen numbers: ( n × 2**n + 1) |
||
Line 697: | Line 697: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
load "stdlib.ring" |
load "stdlib.ring" |
||
Line 716: | Line 716: | ||
see nl + "done..." + nl |
see nl + "done..." + nl |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 729: | Line 729: | ||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
< |
<syntaxhighlight lang="rust">// [dependencies] |
||
// rug = "1.15.0" |
// rug = "1.15.0" |
||
Line 773: | Line 773: | ||
.collect(); |
.collect(); |
||
println!("{}", woodall_primes.join(" ")); |
println!("{}", woodall_primes.join(" ")); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 791: | Line 791: | ||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
< |
<syntaxhighlight lang="ruby">func cullen(n) { n * (1 << n) + 1 } |
||
func woodall(n) { n * (1 << n) - 1 } |
func woodall(n) { n * (1 << n) - 1 } |
||
Line 804: | Line 804: | ||
say "\nFirst 12 Woodall primes: (in terms of n)" |
say "\nFirst 12 Woodall primes: (in terms of n)" |
||
say 12.by { woodall(_).is_prime }.join(' ')</ |
say 12.by { woodall(_).is_prime }.join(' ')</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 821: | Line 821: | ||
=={{header|Verilog}}== |
=={{header|Verilog}}== |
||
< |
<syntaxhighlight lang="verilog">module main; |
||
integer n, num; |
integer n, num; |
||
Line 840: | Line 840: | ||
$finish ; |
$finish ; |
||
end |
end |
||
endmodule</ |
endmodule</syntaxhighlight> |
||
Line 847: | Line 847: | ||
{{libheader|Wren-big}} |
{{libheader|Wren-big}} |
||
Cullen primes limited to first 2 as very slow after that. |
Cullen primes limited to first 2 as very slow after that. |
||
< |
<syntaxhighlight lang="ecmascript">import "./big" for BigInt |
||
var cullen = Fn.new { |n| (BigInt.one << n) * n + 1 } |
var cullen = Fn.new { |n| (BigInt.one << n) * n + 1 } |
||
Line 882: | Line 882: | ||
n = n + 1 |
n = n + 1 |
||
} |
} |
||
System.print()</ |
System.print()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 902: | Line 902: | ||
{{libheader|Wren-gmp}} |
{{libheader|Wren-gmp}} |
||
Cullen primes still slow to emerge, just over 10 seconds overall. |
Cullen primes still slow to emerge, just over 10 seconds overall. |
||
< |
<syntaxhighlight lang="ecmascript">/* cullen_and_woodall_numbers2.wren */ |
||
import "./gmp" for Mpz |
import "./gmp" for Mpz |
||
Line 939: | Line 939: | ||
n = n + 1 |
n = n + 1 |
||
} |
} |
||
System.print()</ |
System.print()</syntaxhighlight> |
||
{{out}} |
{{out}} |
Revision as of 22:49, 26 August 2022
You are encouraged to solve this task according to the task description, using any language you may know.
A Cullen number is a number of the form n × 2n + 1 where n is a natural number.
A Woodall number is very similar. It is a number of the form n × 2n - 1 where n is a natural number.
So for each n the associated Cullen number and Woodall number differ by 2.
Woodall numbers are sometimes referred to as Riesel numbers or Cullen numbers of the second kind.
Cullen primes are Cullen numbers that are prime. Similarly, Woodall primes are Woodall numbers that are prime.
It is common to list the Cullen and Woodall primes by the value of n rather than the full evaluated expression. They tend to get very large very quickly. For example, the third Cullen prime, n == 4713, has 1423 digits when evaluated.
- Task
- Write procedures to find Cullen numbers and Woodall numbers.
- Use those procedures to find and show here, on this page the first 20 of each.
- Stretch
- Find and show the first 5 Cullen primes in terms of n.
- Find and show the first 12 Woodall primes in terms of n.
- See also
ALGOL 68
Uses Algol 68Gs LONG LONG INT for long integers. The number of digits must be specified and appears to affect the run time as larger sies are specified. This sample only shows the first two Cullen primes as the time taken to find the third is rather long.
BEGIN # find Cullen and Woodall numbers and determine which are prime #
# a Cullen number n is n2^2 + 1, Woodall number is n2^n - 1 #
PR read "primes.incl.a68" PR # include prime utilities #
PR precision 800 PR # set number of digits for Algol 68G LONG LONG INT #
# returns the nth Cullen number #
OP CULLEN = ( INT n )LONG LONG INT: n * LONG LONG INT(2)^n + 1;
# returns the nth Woodall number #
OP WOODALL = ( INT n )LONG LONG INT: CULLEN n - 2;
# show the first 20 Cullen numbers #
print( ( "1st 20 Cullen numbers:" ) );
FOR n TO 20 DO
print( ( " ", whole( CULLEN n, 0 ) ) )
OD;
print( ( newline ) );
# show the first 20 Woodall numbers #
print( ( "1st 20 Woodall numbers:" ) );
FOR n TO 20 DO
print( ( " ", whole( WOODALL n, 0 ) ) )
OD;
print( ( newline ) );
BEGIN # first 2 Cullen primes #
print( ( "Index of the 1st 2 Cullen primes:" ) );
LONG LONG INT power of 2 := 1;
INT prime count := 0;
FOR n WHILE prime count < 2 DO
power of 2 *:= 2;
LONG LONG INT c n = ( n * power of 2 ) + 1;
IF is probably prime( c n ) THEN
prime count +:= 1;
print( ( " ", whole( n, 0 ) ) )
FI
OD;
print( ( newline ) )
END;
BEGIN # first 12 Woodall primes #
print( ( "Index of the 1st 12 Woodall primes:" ) );
LONG LONG INT power of 2 := 1;
INT prime count := 0;
FOR n WHILE prime count < 12 DO
power of 2 *:= 2;
LONG LONG INT w n = ( n * power of 2 ) - 1;
IF is probably prime( w n ) THEN
prime count +:= 1;
print( ( " ", whole( n, 0 ) ) )
FI
OD;
print( ( newline ) )
END
END
- Output:
1st 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 1st 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 Index of the 1st 2 Cullen primes: 1 141 Index of the 1st 12 Woodall primes: 2 3 6 30 75 81 115 123 249 362 384 462
Arturo
cullen: function [n]->
inc n * 2^n
woodall: function [n]->
dec n * 2^n
print ["First 20 cullen numbers:" join.with:" " to [:string] map 1..20 => cullen]
print ["First 20 woodall numbers:" join.with:" " to [:string] map 1..20 => woodall]
- Output:
First 20 cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519
AWK
# syntax: GAWK -f CULLEN_AND_WOODALL_NUMBERS.AWK
BEGIN {
start = 1
stop = 20
printf("Cullen %d-%d:",start,stop)
for (n=start; n<=stop; n++) {
printf(" %d",n*(2^n)+1)
}
printf("\n")
printf("Woodall %d-%d:",start,stop)
for (n=start; n<=stop; n++) {
printf(" %d",n*(2^n)-1)
}
printf("\n")
exit(0)
}
- Output:
Cullen 1-20: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 Woodall 1-20: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519
BASIC
BASIC256
print "First 20 Cullen numbers:"
for n = 1 to 20
num = n * (2^n)+1
print int(num); " ";
next
print : print
print "First 20 Woodall numbers:"
for n = 1 to 20
num = n * (2^n)-1
print int(num); " ";
next n
end
- Output:
Igual que la entrada de FreeBASIC.
FreeBASIC
Dim As Uinteger n, num
Print "First 20 Cullen numbers:"
For n = 1 To 20
num = n * (2^n)+1
Print num; " ";
Next
Print !"\n\nFirst 20 Woodall numbers:"
For n = 1 To 20
num = n * (2^n)-1
Print num; " ";
Next n
Sleep
- Output:
First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519
PureBasic
OpenConsole()
PrintN("First 20 Cullen numbers:")
For n.i = 1 To 20
num = n * Pow(2, n)+1
Print(Str(num) + " ")
Next
PrintN(#CRLF$ + "First 20 Woodall numbers:")
For n.i = 1 To 20
num = n * Pow(2, n)-1
Print(Str(num) + " ")
Next n
PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input()
CloseConsole()
- Output:
Igual que la entrada de FreeBASIC.
QBasic
DIM num AS LONG ''comment this line for True BASIC
PRINT "First 20 Cullen numbers:"
FOR n = 1 TO 20
LET num = n * (2 ^ n) + 1
PRINT num;
NEXT n
PRINT
PRINT
PRINT "First 20 Woodall numbers:"
FOR n = 1 TO 20
LET num = n * (2 ^ n) - 1
PRINT num;
NEXT n
END
- Output:
Igual que la entrada de FreeBASIC.
True BASIC
REM DIM num AS LONG !uncomment this line for QBasic
PRINT "First 20 Cullen numbers:"
FOR n = 1 TO 20
LET num = n * (2 ^ n) + 1
PRINT num;
NEXT n
PRINT
PRINT
PRINT "First 20 Woodall numbers:"
FOR n = 1 TO 20
LET num = n * (2 ^ n) - 1
PRINT num;
NEXT n
END
- Output:
Igual que la entrada de FreeBASIC.
Yabasic
print "First 20 Cullen numbers:"
for n = 1 to 20
num = n * (2^n)+1
print num, " ";
next
print "\n\nFirst 20 Woodall numbers:"
for n = 1 to 20
num = n * (2^n)-1
print num, " ";
next n
print
end
- Output:
Igual que la entrada de FreeBASIC.
F#
// Cullen and Woodall numbers. Nigel Galloway: January 14th., 2022
let Cullen,Woodall=let fG n (g:int)=(bigint g)*2I**g+n in fG 1I, fG -1I
Seq.initInfinite((+)1>>Cullen)|>Seq.take 20|>Seq.iter(printf "%A "); printfn ""
Seq.initInfinite((+)1>>Woodall)|>Seq.take 20|>Seq.iter(printf "%A "); printfn ""
Seq.initInfinite((+)1)|>Seq.filter(fun n->let mutable n=Woodall n in Open.Numeric.Primes.MillerRabin.IsProbablePrime &n)|>Seq.take 12|>Seq.iter(printf "%A "); printfn ""
Seq.initInfinite((+)1)|>Seq.filter(fun n->let mutable n=Cullen n in Open.Numeric.Primes.MillerRabin.IsProbablePrime &n)|>Seq.take 5|>Seq.iter(printf "%A "); printfn ""
- Output:
3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 2 3 6 30 75 81 115 123 249 362 384 462 1 141 4713 5795 6611
Factor
USING: arrays kernel math math.vectors prettyprint ranges
sequences ;
20 [1..b] [ dup 2^ * 1 + ] map dup 2 v-n 2array simple-table.
- Output:
3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519
Go
package main
import (
"fmt"
big "github.com/ncw/gmp"
)
func cullen(n uint) *big.Int {
one := big.NewInt(1)
bn := big.NewInt(int64(n))
res := new(big.Int).Lsh(one, n)
res.Mul(res, bn)
return res.Add(res, one)
}
func woodall(n uint) *big.Int {
res := cullen(n)
return res.Sub(res, big.NewInt(2))
}
func main() {
fmt.Println("First 20 Cullen numbers (n * 2^n + 1):")
for n := uint(1); n <= 20; n++ {
fmt.Printf("%d ", cullen(n))
}
fmt.Println("\n\nFirst 20 Woodall numbers (n * 2^n - 1):")
for n := uint(1); n <= 20; n++ {
fmt.Printf("%d ", woodall(n))
}
fmt.Println("\n\nFirst 5 Cullen primes (in terms of n):")
count := 0
for n := uint(1); count < 5; n++ {
cn := cullen(n)
if cn.ProbablyPrime(15) {
fmt.Printf("%d ", n)
count++
}
}
fmt.Println("\n\nFirst 12 Woodall primes (in terms of n):")
count = 0
for n := uint(1); count < 12; n++ {
cn := woodall(n)
if cn.ProbablyPrime(15) {
fmt.Printf("%d ", n)
count++
}
}
fmt.Println()
}
- Output:
First 20 Cullen numbers (n * 2^n + 1): 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers (n * 2^n - 1): 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 5 Cullen primes (in terms of n): 1 141 4713 5795 6611 First 12 Woodall primes (in terms of n): 2 3 6 30 75 81 115 123 249 362 384 462
Haskell
findCullen :: Int -> Integer
findCullen n = toInteger ( n * 2 ^ n + 1 )
cullens :: [Integer]
cullens = map findCullen [1 .. 20]
woodalls :: [Integer]
woodalls = map (\i -> i - 2 ) cullens
main :: IO ( )
main = do
putStrLn "First 20 Cullen numbers:"
print cullens
putStrLn "First 20 Woodall numbers:"
print woodalls
- Output:
First 20 Cullen numbers: [3,9,25,65,161,385,897,2049,4609,10241,22529,49153,106497,229377,491521,1048577,2228225,4718593,9961473,20971521] First 20 Woodall numbers: [1,7,23,63,159,383,895,2047,4607,10239,22527,49151,106495,229375,491519,1048575,2228223,4718591,9961471,20971519]
J
cullen=: {{ y* 1+2x^y }}
woodall=: {{ y*_1+2x^y }}
Task example:
cullen 1+i.20
3 10 27 68 165 390 903 2056 4617 10250 22539 49164 106509 229390 491535 1048592 2228241 4718610 9961491 20971540
woodall 1+i.20
1 6 21 60 155 378 889 2040 4599 10230 22517 49140 106483 229362 491505 1048560 2228207 4718574 9961453 20971500
Julia
using Lazy
using Primes
cullen(n, two = BigInt(2)) = n * two^n + 1
woodall(n, two = BigInt(2)) = n * two^n - 1
primecullens = @>> Lazy.range() filter(n -> isprime(cullen(n)))
primewoodalls = @>> Lazy.range() filter(n -> isprime(woodall(n)))
println("First 20 Cullen numbers: ( n × 2**n + 1)\n", [cullen(n, 2) for n in 1:20]) # A002064
println("First 20 Woodall numbers: ( n × 2**n - 1)\n", [woodall(n, 2) for n in 1:20]) # A003261
println("\nFirst 5 Cullen primes: (in terms of n)\n", take(5, primecullens)) # A005849
println("\nFirst 12 Woodall primes: (in terms of n)\n", Int.(collect(take(12, primewoodalls)))) # A002234
- Output:
First 20 Cullen numbers: ( n × 2**n + 1) [3, 9, 25, 65, 161, 385, 897, 2049, 4609, 10241, 22529, 49153, 106497, 229377, 491521, 1048577, 2228225, 4718593, 9961473, 20971521] First 20 Woodall numbers: ( n × 2**n - 1) [1, 7, 23, 63, 159, 383, 895, 2047, 4607, 10239, 22527, 49151, 106495, 229375, 491519, 1048575, 2228223, 4718591, 9961471, 20971519] First 5 Cullen primes: (in terms of n) List: (1 141 4713 5795 6611) First 12 Woodall primes: (in terms of n) [2, 3, 6, 30, 75, 81, 115, 123, 249, 362, 384, 462]
Lua
function T(t) return setmetatable(t, {__index=table}) end
table.range = function(t,n) local s=T{} for i=1,n do s[i]=i end return s end
table.map = function(t,f) local s=T{} for i=1,#t do s[i]=f(t[i]) end return s end
function cullen(n) return (n<<n)+1 end
print("First 20 Cullen numbers:")
print(T{}:range(20):map(cullen):concat(" "))
function woodall(n) return (n<<n)-1 end
print("First 20 Woodall numbers:")
print(T{}:range(20):map(woodall):concat(" "))
- Output:
First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519
Mathematica/Wolfram Language
ClearAll[CullenNumber, WoodallNumber]
SetAttributes[{CullenNumber, WoodallNumber}, Listable]
CullenNumber[n_Integer] := n 2^n + 1
WoodallNumber[n_Integer] := n 2^n - 1
CullenNumber[Range[20]]
WoodallNumber[Range[20]]
cps = {};
Do[
If[PrimeQ[CullenNumber[i]],
AppendTo[cps, i];
If[Length[cps] >= 5, Break[]]
]
,
{i, 1, \[Infinity]}
]
cps
wps = {};
Do[
If[PrimeQ[WoodallNumber[i]],
AppendTo[wps, i];
If[Length[wps] >= 12, Break[]]
]
,
{i, 1, \[Infinity]}
];
wps
- Output:
{3, 9, 25, 65, 161, 385, 897, 2049, 4609, 10241, 22529, 49153, 106497, 229377, 491521, 1048577, 2228225, 4718593, 9961473, 20971521} {1, 7, 23, 63, 159, 383, 895, 2047, 4607, 10239, 22527, 49151, 106495, 229375, 491519, 1048575, 2228223, 4718591, 9961471, 20971519} {1, 141, 4713, 5795, 6611} {2, 3, 6, 30, 75, 81, 115, 123, 249, 362, 384, 462}
Perl
use strict;
use warnings;
use bigint;
use ntheory 'is_prime';
use constant Inf => 1e10;
sub cullen {
my($n,$c) = @_;
($n * 2**$n) + $c;
}
my($m,$n);
($m,$n) = (20,0);
print "First $m Cullen numbers:\n";
print do { $n < $m ? (++$n and cullen($_,1) . ' ') : last } for 1 .. Inf;
($m,$n) = (20,0);
print "\n\nFirst $m Woodall numbers:\n";
print do { $n < $m ? (++$n and cullen($_,-1) . ' ') : last } for 1 .. Inf;
($m,$n) = (5,0);
print "\n\nFirst $m Cullen primes: (in terms of n)\n";
print do { $n < $m ? (!!is_prime(cullen $_,1) and ++$n and "$_ ") : last } for 1 .. Inf;
($m,$n) = (12,0);
print "\n\nFirst $m Woodall primes: (in terms of n)\n";
print do { $n < $m ? (!!is_prime(cullen $_,-1) and ++$n and "$_ ") : last } for 1 .. Inf;
- Output:
First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 5 Cullen primes: (in terms of n) 1 141 4713 5795 6611 First 12 Woodall primes: (in terms of n) 2 3 6 30 75 81 115 123 249 362 384 462
Phix
with javascript_semantics atom t0 = time() include mpfr.e procedure cullen(mpz r, integer n) mpz_ui_pow_ui(r,2,n) mpz_mul_si(r,r,n) mpz_add_si(r,r,1) end procedure procedure woodall(mpz r, integer n) cullen(r,n) mpz_sub_si(r,r,2) end procedure sequence c = {}, w = {} mpz z = mpz_init() for i=1 to 20 do cullen(z,i) c = append(c,mpz_get_str(z)) mpz_sub_si(z,z,2) w = append(w,mpz_get_str(z)) end for printf(1," Cullen[1..20]:%s\nWoodall[1..20]:%s\n",{join(c),join(w)}) atom t1 = time()+1 c = {} integer n = 1 while length(c)<iff(platform()=JS?2:5) do cullen(z,n) if mpz_prime(z) then c = append(c,sprint(n)) end if n += 1 if time()>t1 and platform()!=JS then progress("c(%d) [needs to get to 6611], %d found\r",{n,length(c)}) t1 = time()+2 end if end while if platform()!=JS then progress("") end if printf(1,"First 5 Cullen primes (in terms of n):%s\n",{join(c)}) w = {} n = 1 while length(w)<12 do woodall(z,n) if mpz_prime(z) then w = append(w,sprint(n)) end if n += 1 end while printf(1,"First 12 Woodall primes (in terms of n):%s\n",{join(w)}) ?elapsed(time()-t0)
- Output:
Cullen[1..20]:3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 Woodall[1..20]:1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 5 Cullen primes (in terms of n):1 141 4713 5795 6611 First 12 Woodall primes (in terms of n):2 3 6 30 75 81 115 123 249 362 384 462 "34.4s"
Note the time given is for desktop/Phix 64bit, for comparison the Julia entry took about 20s on the same box. On 32-bit it is nearly 5 times slower (2 minutes and 38s) and hence under pwa/p2js in a browser (which is inherently 32bit) it is limited to the first 2 cullen primes only, but manages that in 0.4s.
Python
print("working...")
print("First 20 Cullen numbers:")
for n in range(1,20):
num = n*pow(2,n)+1
print(str(num),end= " ")
print()
print("First 20 Woodall numbers:")
for n in range(1,20):
num = n*pow(2,n)-1
print(str(num),end=" ")
print()
print("done...")
- Output:
working... First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 done...
Bit Shift
def cullen(n): return((n<<n)+1)
def woodall(n): return((n<<n)-1)
print("First 20 Cullen numbers:")
for i in range(1,20):
print(cullen(i),end=" ")
print()
print()
print("First 20 Woodall numbers:")
for i in range(1,20):
print(woodall(i),end=" ")
print()
- Output:
Same as Quackery.
Quackery
[ dup << 1+ ] is cullen ( n --> n )
[ dup << 1 - ] is woodall ( n --> n )
say "First 20 Cullen numbers:" cr
20 times [ i^ 1+ cullen echo sp ] cr
cr
say "First 20 Woodall numbers:" cr
20 times [ i^ 1+ woodall echo sp ] cr
- Output:
First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519
Raku
my @cullen = ^∞ .map: { $_ × 1 +< $_ + 1 };
my @woodall = ^∞ .map: { $_ × 1 +< $_ - 1 };
put "First 20 Cullen numbers: ( n × 2**n + 1)\n", @cullen[1..20]; # A002064
put "\nFirst 20 Woodall numbers: ( n × 2**n - 1)\n", @woodall[1..20]; # A003261
put "\nFirst 5 Cullen primes: (in terms of n)\n", @cullen.grep( &is-prime, :k )[^5]; # A005849
put "\nFirst 12 Woodall primes: (in terms of n)\n", @woodall.grep( &is-prime, :k )[^12]; # A002234
- Output:
First 20 Cullen numbers: ( n × 2**n + 1) 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: ( n × 2**n - 1) 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 5 Cullen primes: (in terms of n) 1 141 4713 5795 6611 First 12 Woodall primes: (in terms of n) 2 3 6 30 75 81 115 123 249 362 384 462
Ring
load "stdlib.ring"
see "working..." + nl
see "First 20 Cullen numbers:" + nl
for n = 1 to 20
num = n*pow(2,n)+1
see "" + num + " "
next
see nl + nl + "First 20 Woodall numbers:" + nl
for n = 1 to 20
num = n*pow(2,n)-1
see "" + num + " "
next
see nl + "done..." + nl
- Output:
working... First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 done...
Rust
// [dependencies]
// rug = "1.15.0"
use rug::integer::IsPrime;
use rug::Integer;
fn cullen_number(n: u32) -> Integer {
let num = Integer::from(n);
(num << n) + 1
}
fn woodall_number(n: u32) -> Integer {
let num = Integer::from(n);
(num << n) - 1
}
fn main() {
println!("First 20 Cullen numbers:");
let cullen: Vec<String> = (1..21).map(|x| cullen_number(x).to_string()).collect();
println!("{}", cullen.join(" "));
println!("\nFirst 20 Woodall numbers:");
let woodall: Vec<String> = (1..21).map(|x| woodall_number(x).to_string()).collect();
println!("{}", woodall.join(" "));
println!("\nFirst 5 Cullen primes in terms of n:");
let cullen_primes: Vec<String> = (1..)
.filter_map(|x| match cullen_number(x).is_probably_prime(25) {
IsPrime::No => None,
_ => Some(x.to_string()),
})
.take(5)
.collect();
println!("{}", cullen_primes.join(" "));
println!("\nFirst 12 Woodall primes in terms of n:");
let woodall_primes: Vec<String> = (1..)
.filter_map(|x| match woodall_number(x).is_probably_prime(25) {
IsPrime::No => None,
_ => Some(x.to_string()),
})
.take(12)
.collect();
println!("{}", woodall_primes.join(" "));
}
- Output:
First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 5 Cullen primes in terms of n: 1 141 4713 5795 6611 First 12 Woodall primes in terms of n: 2 3 6 30 75 81 115 123 249 362 384 462
Sidef
func cullen(n) { n * (1 << n) + 1 }
func woodall(n) { n * (1 << n) - 1 }
say "First 20 Cullen numbers:"
say cullen.map(1..20).join(' ')
say "\nFirst 20 Woodall numbers:"
say woodall.map(1..20).join(' ')
say "\nFirst 5 Cullen primes: (in terms of n)"
say 5.by { cullen(_).is_prime }.join(' ')
say "\nFirst 12 Woodall primes: (in terms of n)"
say 12.by { woodall(_).is_prime }.join(' ')
- Output:
First 20 Cullen numbers: 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers: 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 5 Cullen primes: (in terms of n) 1 141 4713 5795 6611 First 12 Woodall primes: (in terms of n) 2 3 6 30 75 81 115 123 249 362 384 462
Verilog
module main;
integer n, num;
initial begin
$display("First 20 Cullen numbers:");
for(n = 1; n <= 20; n=n+1)
begin
num = n * (2 ** n) + 1;
$write(num, " ");
end
$display("");
$display("First 20 Woodall numbers:");
for(n = 1; n <= 20; n=n+1)
begin
num = n * (2 ** n) - 1;
$write(num, " ");
end
$finish ;
end
endmodule
Wren
CLI
Cullen primes limited to first 2 as very slow after that.
import "./big" for BigInt
var cullen = Fn.new { |n| (BigInt.one << n) * n + 1 }
var woodall = Fn.new { |n| cullen.call(n) - 2 }
System.print("First 20 Cullen numbers (n * 2^n + 1):")
for (n in 1..20) System.write("%(cullen.call(n)) ")
System.print("\n\nFirst 20 Woodall numbers (n * 2^n - 1):")
for (n in 1..20) System.write("%(woodall.call(n)) ")
System.print("\n\nFirst 2 Cullen primes (in terms of n):")
var count = 0
var n = 1
while (count < 2) {
var cn = cullen.call(n)
if (cn.isProbablePrime(5)){
System.write("%(n) ")
count = count + 1
}
n = n + 1
}
System.print("\n\nFirst 12 Woodall primes (in terms of n):")
count = 0
n = 1
while (count < 12) {
var wn = woodall.call(n)
if (wn.isProbablePrime(5)){
System.write("%(n) ")
count = count + 1
}
n = n + 1
}
System.print()
- Output:
First 20 Cullen numbers (n * 2^n + 1): 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers (n * 2^n - 1): 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 2 Cullen primes (in terms of n): 1 141 First 12 Woodall primes (in terms of n): 2 3 6 30 75 81 115 123 249 362 384 462
Embedded
Cullen primes still slow to emerge, just over 10 seconds overall.
/* cullen_and_woodall_numbers2.wren */
import "./gmp" for Mpz
var cullen = Fn.new { |n| (Mpz.one << n) * n + 1 }
var woodall = Fn.new { |n| cullen.call(n) - 2 }
System.print("First 20 Cullen numbers (n * 2^n + 1):")
for (n in 1..20) System.write("%(cullen.call(n)) ")
System.print("\n\nFirst 20 Woodall numbers (n * 2^n - 1):")
for (n in 1..20) System.write("%(woodall.call(n)) ")
System.print("\n\nFirst 5 Cullen primes (in terms of n):")
var count = 0
var n = 1
while (count < 5) {
var cn = cullen.call(n)
if (cn.probPrime(15) > 0){
System.write("%(n) ")
count = count + 1
}
n = n + 1
}
System.print("\n\nFirst 12 Woodall primes (in terms of n):")
count = 0
n = 1
while (count < 12) {
var wn = woodall.call(n)
if (wn.probPrime(15) > 0){
System.write("%(n) ")
count = count + 1
}
n = n + 1
}
System.print()
- Output:
First 20 Cullen numbers (n * 2^n + 1): 3 9 25 65 161 385 897 2049 4609 10241 22529 49153 106497 229377 491521 1048577 2228225 4718593 9961473 20971521 First 20 Woodall numbers (n * 2^n - 1): 1 7 23 63 159 383 895 2047 4607 10239 22527 49151 106495 229375 491519 1048575 2228223 4718591 9961471 20971519 First 5 Cullen primes (in terms of n): 1 141 4713 5795 6611 First 12 Woodall primes (in terms of n): 2 3 6 30 75 81 115 123 249 362 384 462