Cullen and Woodall numbers

From Rosetta Code
Task
Cullen and Woodall numbers
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

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32

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.

Library: ALGOL 68-primes

<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     #
   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</lang>

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

<lang rebol>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]</lang>

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

<lang AWK>

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

} </lang>

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

Translation of: FreeBASIC

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

Output:
Igual que la entrada de FreeBASIC.

FreeBASIC

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

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

<lang 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()</lang>

Output:
Igual que la entrada de FreeBASIC.

QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Works with: True BASIC
Translation of: FreeBASIC

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

Output:
Igual que la entrada de FreeBASIC.

True BASIC

Works with: QBasic
Translation of: FreeBASIC

<lang qbasic>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</lang>

Output:
Igual que la entrada de FreeBASIC.

Yabasic

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

Output:
Igual que la entrada de FreeBASIC.


F#

<lang fsharp> // 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 "" </lang>

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

Works with: Factor version 0.99 2022-04-03

<lang factor>USING: arrays kernel math math.vectors prettyprint ranges sequences ;

20 [1..b] [ dup 2^ * 1 + ] map dup 2 v-n 2array simple-table.</lang>

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

Library: GMP(Go wrapper)

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

}</lang>

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

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

Julia

Translation of: Raku

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

</lang>

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

<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.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(" "))</lang>

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

<lang Mathematica>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</lang>

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

Library: ntheory

<lang 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;</lang>

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

<lang 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...") </lang>

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

Translation of: Quackery

<lang Python>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()</lang>

Output:

Same as Quackery.

Quackery

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

<lang perl6>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</lang>

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

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

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

<lang 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(" "));

}</lang>

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

<lang ruby>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(' ')</lang>

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

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


Wren

CLI

Library: Wren-big

Cullen primes limited to first 2 as very slow after that. <lang ecmascript>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()</lang>

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

Library: Wren-gmp

Cullen primes still slow to emerge, just over 10 seconds overall. <lang ecmascript>/* 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()</lang>

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
Retrieved from "https://rosettacode.org/wiki/Cullen_and_Woodall_numbers?oldid=318927"