Data commit

Task/Prime-decomposition/C/prime-decomposition-1.c

@@ -0,0 +1,171 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+typedef uint32_t pint;
+typedef uint64_t xint;
+typedef unsigned int uint;
+#define PRIuPINT PRIu32     /* printf macro for pint */
+#define PRIuXINT PRIu64     /* printf macro for xint */
+#define MAX_FACTORS 63      /* because 2^64 is too large for xint */
+
+uint8_t *pbits;
+
+#define MAX_PRIME (~(pint)0)
+#define MAX_PRIME_SQ 65535U
+#define PBITS (MAX_PRIME / 30 + 1)
+
+pint next_prime(pint);
+int is_prime(xint);
+void sieve(pint);
+
+uint8_t bit_pos[30] = {
+    0, 1<<0, 0, 0, 0,    0,
+    0, 1<<1, 0, 0, 0, 1<<2,
+    0, 1<<3, 0, 0, 0, 1<<4,
+    0, 1<<5, 0, 0, 0, 1<<6,
+    0,    0, 0, 0, 0, 1<<7,
+};
+
+uint8_t rem_num[] = { 1, 7, 11, 13, 17, 19, 23, 29 };
+
+void init_primes()
+{
+    FILE *fp;
+    pint s, tgt = 4;
+
+    if (!(pbits = malloc(PBITS))) {
+        perror("malloc");
+        exit(1);
+    }
+
+    if ((fp = fopen("primebits", "r"))) {
+        fread(pbits, 1, PBITS, fp);
+        fclose(fp);
+        return;
+    }
+
+    memset(pbits, 255, PBITS);
+    for (s = 7; s <= MAX_PRIME_SQ; s = next_prime(s)) {
+        if (s > tgt) {
+            tgt *= 2;
+            fprintf(stderr, "sieve %"PRIuPINT"\n", s);
+        }
+        sieve(s);
+    }
+    fp = fopen("primebits", "w");
+    fwrite(pbits, 1, PBITS, fp);
+    fclose(fp);
+}
+
+int is_prime(xint x)
+{
+    pint p;
+    if (x > 5) {
+        if (x < MAX_PRIME)
+            return pbits[x/30] & bit_pos[x % 30];
+
+        for (p = 2; p && (xint)p * p <= x; p = next_prime(p))
+            if (x % p == 0) return 0;
+
+        return 1;
+    }
+    return x == 2 || x == 3 || x == 5;
+}
+
+void sieve(pint p)
+{
+    unsigned char b[8];
+    off_t ofs[8];
+    int i, q;
+
+    for (i = 0; i < 8; i++) {
+        q = rem_num[i] * p;
+        b[i] = ~bit_pos[q % 30];
+        ofs[i] = q / 30;
+    }
+
+    for (q = ofs[1], i = 7; i; i--)
+        ofs[i] -= ofs[i-1];
+
+    for (ofs[0] = p, i = 1; i < 8; i++)
+        ofs[0] -= ofs[i];
+
+    for (i = 1; q < PBITS; q += ofs[i = (i + 1) & 7])
+        pbits[q] &= b[i];
+}
+
+pint next_prime(pint p)
+{
+    off_t addr;
+    uint8_t bits, rem;
+
+    if (p > 5) {
+        addr = p / 30;
+        bits = bit_pos[ p % 30 ] << 1;
+        for (rem = 0; (1 << rem) < bits; rem++);
+        while (pbits[addr] < bits || !bits) {
+            if (++addr >= PBITS) return 0;
+            bits = 1;
+            rem = 0;
+        }
+        if (addr >= PBITS) return 0;
+        while (!(pbits[addr] & bits)) {
+            rem++;
+            bits <<= 1;
+        }
+        return p = addr * 30 + rem_num[rem];
+    }
+
+    switch(p) {
+        case 2: return 3;
+        case 3: return 5;
+        case 5: return 7;
+    }
+    return 2;
+}
+
+int decompose(xint n, xint *f)
+{
+    pint p = 0;
+    int i = 0;
+
+    /* check small primes: not strictly necessary */
+    if (n <= MAX_PRIME && is_prime(n)) {
+        f[0] = n;
+        return 1;
+    }
+
+    while (n >= (xint)p * p) {
+        if (!(p = next_prime(p))) break;
+        while (n % p == 0) {
+            n /= p;
+            f[i++] = p;
+        }
+    }
+    if (n > 1) f[i++] = n;
+    return i;
+}
+
+int main()
+{
+    int i, len;
+    pint p = 0;
+    xint f[MAX_FACTORS], po;
+
+    init_primes();
+
+    for (p = 1; p < 64; p++) {
+        po = (1LLU << p) - 1;
+        printf("2^%"PRIuPINT" - 1 = %"PRIuXINT, p, po);
+        fflush(stdout);
+        if ((len = decompose(po, f)) > 1)
+            for (i = 0; i < len; i++)
+                printf(" %c %"PRIuXINT, i?'x':'=', f[i]);
+        putchar('\n');
+    }
+
+    return 0;
+}

Task/Prime-decomposition/C/prime-decomposition-2.c

@@ -0,0 +1,107 @@
+#include <limits.h>
+#include <stdio.h>
+#include <math.h>
+
+typedef enum{false=0, true=1}bool;
+const int max_lint = LONG_MAX;
+
+typedef long long int lint;
+#assert sizeof_long_long_int (LONG_MAX>=8) /* XXX */
+
+/* the following line is the only time I have ever required "auto" */
+#define FOR(i,iterator) auto bool lambda(i); yield_init = (void *)&lambda; iterator; bool lambda(i)
+#define DO {
+#define     YIELD(x) if(!yield(x))return
+#define     BREAK return false
+#define     CONTINUE return true
+#define OD CONTINUE; }
+/* Warning: _Most_ FOR(,){ } loops _must_ have a CONTINUE as the last statement.
+ *   Otherwise the lambda will return random value from stack, and may terminate early */
+
+typedef void iterator, lint_iterator; /* hint at procedure purpose */
+static volatile void *yield_init; /* not thread safe */
+#define YIELDS(type) bool (*yield)(type) = yield_init
+
+typedef unsigned int bits;
+#define ELEM(shift, bits) ( (bits >> shift) & 0b1 )
+
+bits cache = 0b0, cached = 0b0;
+const lint upb_cache = 8 * sizeof(cache);
+
+lint_iterator decompose(lint); /* forward declaration */
+
+bool is_prime(lint n){
+   bool has_factor = false, out = true;
+/* for factor in decompose(n) do */
+   FOR(lint factor, decompose(n)){
+       if( has_factor ){ out = false; BREAK; }
+       has_factor = true;
+       CONTINUE;
+   }
+   return out;
+}
+
+bool is_prime_cached (lint n){
+    lint half_n = n / 2 - 2;
+    if( half_n <= upb_cache){
+        /* dont cache the initial four, nor the even numbers */
+        if (ELEM(half_n,cached)){
+            return ELEM(half_n,cache);
+        } else {
+            bool out = is_prime(n);
+            cache = cache | out << half_n;
+            cached = cached | 0b1 << half_n;
+            return out;
+        }
+    } else {
+        return is_prime(n);
+    }
+}
+
+lint_iterator primes (){
+    YIELDS(lint);
+    YIELD(2);
+    lint n = 3;
+    while( n < max_lint - 2 ){
+        YIELD(n);
+        n += 2;
+        while( n < max_lint - 2 && ! is_prime_cached(n) ){
+            n += 2;
+        }
+    }
+}
+
+lint_iterator decompose (lint in_n){
+    YIELDS(lint);
+    lint n = in_n;
+ /* for p in primes do */
+    FOR(lint p, primes()){
+        if( p*p > n ){
+            BREAK;
+        } else {
+            while( n % p == 0 ){
+                YIELD(p);
+                n = n / p;
+            }
+        }
+        CONTINUE;
+    }
+    if( n > 1 ){
+        YIELD(n);
+    }
+}
+
+main(){
+    FOR(lint m, primes()){
+        lint p = powl(2, m) - 1;
+        printf("2**%lld-1 = %lld, with factors:",m,p);
+        FOR(lint factor, decompose(p)){
+            printf(" %lld",factor);
+            fflush(stdout);
+            CONTINUE;
+        }
+        printf("\n",m);
+        if( m >= 59 )BREAK;
+        CONTINUE;
+    }
+}

Task/Prime-decomposition/C/prime-decomposition-3.c

@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef uint32_t pint;
+typedef uint64_t xint;
+typedef unsigned int uint;
+
+int is_prime(xint);
+
+inline int next_prime(pint p)
+{
+    if (p == 2) return 3;
+    for (p += 2; p > 1 && !is_prime(p); p += 2);
+    if (p == 1) return 0;
+    return p;
+}
+
+int is_prime(xint n)
+{
+#   define NCACHE 256
+#   define S (sizeof(uint) * 2)
+    static uint cache[NCACHE] = {0};
+
+    pint p = 2;
+    int ofs, bit = -1;
+
+    if (n < NCACHE * S) {
+        ofs = n / S;
+        bit = 1 << ((n & (S - 1)) >> 1);
+        if (cache[ofs] & bit) return 1;
+    }
+
+    do {
+        if (n % p == 0) return 0;
+        if (p * p > n) break;
+    } while ((p = next_prime(p)));
+
+    if (bit != -1) cache[ofs] |= bit;
+    return 1;
+}
+
+int decompose(xint n, pint *out)
+{
+    int i = 0;
+    pint p = 2;
+    while (n > p * p) {
+        while (n % p == 0) {
+            out[i++] = p;
+            n /= p;
+        }
+        if (!(p = next_prime(p))) break;
+    }
+    if (n > 1) out[i++] = n;
+    return i;
+}
+
+int main()
+{
+    int i, j, len;
+    xint z;
+    pint out[100];
+    for (i = 2; i < 64; i = next_prime(i)) {
+        z = (1ULL << i) - 1;
+        printf("2^%d - 1 = %llu = ", i, z);
+        fflush(stdout);
+        len = decompose(z, out);
+        for (j = 0; j < len; j++)
+            printf("%u%s", out[j], j < len - 1 ? " x " : "\n");
+    }
+
+    return 0;
+}

Task/Prime-decomposition/C/prime-decomposition-4.c

@@ -0,0 +1,78 @@
+typedef unsigned long long int ulong; // define a type that represent the limit (64-bit)
+
+ulong mod_mul(ulong a, ulong b, const ulong mod) {
+	ulong res = 0, c; // return (a * b) % mod, avoiding overflow errors while doing modular multiplication.
+	for (b %= mod; a; a & 1 ? b >= mod - res ? res -= mod : 0, res += b : 0, a >>= 1, (c = b) >= mod - b ? c -= mod : 0, b += c);
+	return res % mod;
+}
+
+ulong mod_pow(ulong n, ulong exp, const ulong mod) {
+	ulong res = 1; // return (n ^ exp) % mod
+	for (n %= mod; exp; exp & 1 ? res = mod_mul(res, n, mod) : 0, n = mod_mul(n, n, mod), exp >>= 1);
+	return res;
+}
+
+ulong square_root(const ulong N) {
+	ulong res = 0, rem = N, c, d;
+	for (c = 1 << 62; c; c >>= 2) {
+		d = res + c;
+		res >>= 1;
+		if (rem >= d)
+			rem -= d, res += c;
+	} // returns the square root of N.
+	return res;
+}
+
+int is_prime(const ulong N) {
+	ulong i = 1; // return a truthy value about the primality of N.
+	if (N > 1) for (; i < 64 && mod_pow(i, N - 1, N) <= 1; ++i);
+	return i == 64;
+}
+
+ulong pollard_rho(const ulong N) {
+	// Require : N is a composite number, not a square.
+	// Ensure : res is a non-trivial factor of N.
+	// Option : change the timeout, change the rand function.
+	static const int timeout = 18;
+	static unsigned long long rand_val = 2994439072U;
+	rand_val = (rand_val * 1025416097U + 286824428U) % 4294967291LLU;
+	ulong res = 1, a, b, c, i = 0, j = 1, x = 1, y = 1 + rand_val % (N - 1);
+	for (; res == 1; ++i) {
+		if (i == j) {
+			if (j >> timeout)
+				break;
+			j <<= 1;
+			x = y;
+		}
+		a = y, b = y; // performs y = (y * y) % N
+		for (y = 0; a; a & 1 ? b >= N - y ? y -= N : 0, y += b : 0, a >>= 1, (c = b) >= N - b ? c -= N : 0, b += c);
+		y = (1 + y) % N;
+		for (a = y > x ? y - x : x - y, b = N; (a %= b) && (b %= a);); // compute the gcd(abs(y - x), N);
+		res = a | b;
+	}
+	return res;
+}
+
+void factor(const ulong N, ulong *array) {
+	// very basic manager that fill the given array (the size of the result is the first array element)	
+	// it does not perform initial trial divisions, which is generally highly recommended.
+	if (N < 4 || is_prime(N)) {
+		if (N > 1 || !*array) array[++*array] = N;
+		return;
+	}
+	ulong x = square_root(N);
+	if (x * x != N) x = pollard_rho(N);
+	factor(x, array);
+	factor(N / x, array);
+}
+
+#include <stdio.h>
+
+int main(void) {
+	// simple test.
+	unsigned long long n = 18446744073709551615U;
+	ulong fac[65] = {0};
+	factor(n, fac);
+	for (ulong i = 1; i <= *fac; ++i)
+		printf("* %llu\n", fac[i]);
+}