help with prime pairs code

[Jabari Zakiya]

On Tuesday, 4 February 2025 at 17:17:42 UTC, Jabari Zakiya wrote:
> On Monday, 3 February 2025 at 04:59:43 UTC, monkyyy wrote:
>> On Monday, 3 February 2025 at 04:15:09 UTC, Jabari Zakiya 
>> wrote:
>>>
>>> I translated this Ruby code:
>>>
>
>
> FYI.
> This code finds all the prime pairs that sum to n for all even 
> integers n > 2.
> It (Ruby code) is included in a paper I just released (Feb 2, 
> 2025) on Goldbach's Conjecture (1742) and Bertrand's Postulate 
> (1845). For those interested in Prime|Number Theory check it 
> out. A lot of new, good, stuff is in it!
>
> **Proof of Goldbach's Conjecture and Bertrand's Postulate Using 
> Prime Generator Theory (PGT)**
>
> https://www.academia.edu/127404211/Proof_of_Goldbachs_Conjecture_and_Bertrands_Postulate_Using_Prime_Generator_Theory_PGT_

I updated the code to make entering data easier.
It now mimics the Ruby|Crystal code and takes "humanized" data 
strings.
You can now run the code as: `$ ./primes_pair_lohi_u32 
123_456_780`

I also created two versions, one for u32 input values, and one 
for u64.
Unless you have lots of memmory, the u32 version is best to use.

Here's the u32 input size version.

     // Compile with ldc2: $ ldc2 --release -O3 -mcpu native 
prime_pairs_lohi_u32.d
     // Run as: $ ./prime_pairs_lohi_u32 123_456_780

     module prime_pairs;

     import std;
     import std.datetime.stopwatch : StopWatch;

     void prime_pairs_lohi(uint n) {   // inputs can be of size u32
       if ((n&1) == 1 || n < 4) { return writeln("Input not even n 
 > 2"); }
       if (n <= 6) { writeln([n, 1]); writeln([n/2, n/2]); 
writeln([n/2, n/2]); return; }

       // generate the low-half-residues (lhr) r < n/2
       auto ndiv2 = n/2;               // llr:hhr midpoint
       auto rhi   = n-2;               // max residue limit
       uint[] lhr = iota(3, ndiv2, 2).filter!(e => gcd(e, n) == 
1).array;

       // store all the powers of the lhr members < n-2
       uint[] lhr_mults;               // for lhr values not part 
of a pcp
       foreach(r; lhr) {               // step thru the lhr members
         auto r_pwr = r;               // set to first power of r
         if (r > rhi/r_pwr) break;     // exit if r^2 > n-2, as 
all others are too
         while (r < rhi/r_pwr)         // while r^e < n-2
           lhr_mults ~=(r_pwr *= r);   // store its current power 
of rA
       }

       // store all the cross-products of the lhr members < n-2
       foreach(i, r; lhr) {
         auto ri_max = rhi / r;        // ri can't multiply r with 
values > this
         if (lhr[i+1] > ri_max) break; // exit if product of 
consecutive r’s > n-2
         foreach(ri; lhr[i+1..$]) {    // for each residue in 
reduced list
           if (ri > ri_max) break;     // exit for r if 
cross-product with ri > n-2
           lhr_mults ~= r * ri;        // store value if < n-2
       } }

       // convert lhr_mults vals > n/2 to their lhr complements 
n-r,
       // store them, those < n/2, in lhr_del; it now holds 
non-pcp lhr vals
       auto lhr_del = lhr_mults.map!((r_del) => r_del > ndiv2 ? n 
- r_del : r_del).array;
       lhr_del.sort!("a < b");
       lhr = setDifference(lhr, lhr_del).array;

       writeln([n,     lhr.length]);   // show n and pcp prime 
pairs count
       writeln([lhr[0],  n-lhr[0]]);   // show first pcp prime 
pair of n
       writeln([lhr[$-1],n-lhr[$-1]]); // show last  pcp prime 
pair of n
     }

     void main(string[] args) {        // directly recieve input 
from terminal
       string[] inputs = args[1..$];   // can include '_': 123_456
       auto nums = inputs.map!(i => i.filter!(n => n != '_'));
       auto n    = nums.map!(f => f.to!uint())[0];

       auto timer = StopWatch();       // create execution timer
       timer.start();                  // start it
       prime_pairs_lohi(n);            // run routine
       writeln(timer.peek());          // show timer results
     }

Here's the u64 version.


     // Compile with ldc2: $ ldc2 --release -O3 -mcpu native 
prime_pairs_lohi_u64.d
     // Run as: $ ./prime_pairs_lohi_u64 123_456_780

     module prime_pairs;

     import std;
     import std.datetime.stopwatch : StopWatch;

     void prime_pairs_lohi(ulong n) {  // inputs can be of size u64
       if ((n&1) == 1 || n < 4) { return writeln("Input not even n 
 > 2"); }
       if (n <= 6) { writeln([n, 1]); writeln([n/2, n/2]); 
writeln([n/2, n/2]); return; }

       // generate the low-half-residues (lhr) r < n/2
       auto ndiv2 = n/2;               // llr:hhr midpoint
       auto rhi   = n-2;               // max residue limit
       ulong[] lhr = iota(3, ndiv2, 2).filter!(e => gcd(e, n) == 
1).array;

       // store all the powers of the lhr members < n-2
       ulong[] lhr_mults;              // for lhr values not part 
of a pcp
       foreach(r; lhr) {               // step thru the lhr members
         auto r_pwr = r;               // set to first power of r
         if (r > rhi/r_pwr) break;     // exit if r^2 > n-2, as 
all others are too
         while (r < rhi/r_pwr)         // while r^e < n-2
           lhr_mults ~=(r_pwr *= r);   // store its current power 
of rA
       }

       // store all the cross-products of the lhr members < n-2
       foreach(i, r; lhr) {
         auto ri_max = rhi / r;        // ri can't multiply r with 
values > this
         if (lhr[i+1] > ri_max) break; // exit if product of 
consecutive r’s > n-2
         foreach(ri; lhr[i+1..$]) {    // for each residue in 
reduced list
           if (ri > ri_max) break;     // exit for r if 
cross-product with ri > n-2
           lhr_mults ~= r * ri;        // store value if < n-2
       } }

       // convert lhr_mults vals > n/2 to their lhr complements 
n-r,
       // store them, those < n/2, in lhr_del; it now holds 
non-pcp lhr vals
       auto lhr_del = lhr_mults.map!((r_del) => r_del > ndiv2 ? n 
- r_del : r_del).array;
       lhr_del.sort!("a < b");
       lhr = setDifference(lhr, lhr_del).array;

       writeln([n,     lhr.length]);   // show n and pcp prime 
pairs count
       writeln([lhr[0],  n-lhr[0]]);   // show first pcp prime 
pair of n
       writeln([lhr[$-1],n-lhr[$-1]]); // show last  pcp prime 
pair of n
     }

     void main(string[] args) {        // directly recieve input 
from terminal
       string[] inputs = args[1..$];   // can include '_': 123_456
       auto nums = inputs.map!(i => i.filter!(n => n != '_'));
       auto n    = nums.map!(f => f.to!ulong())[0];

       auto timer = StopWatch();       // create execution timer
       timer.start();                  // start it
       prime_pairs_lohi(n);            // run routine
       writeln(timer.peek());          // show timer results
     }