C Faktorisierungsmethode von Dixon / Project Euler

long dixon(int N) {
	int pk = exp(0.5 * sqrt(log(N) * log(log(N))));
	int* P = getAllFromSieveOfEratosthenes(pk); // factor base
	// Try to get x_i as ceil(sqrt(N)) < x_i < N and factorize as
	// a_i % x_i^(2) % N. (de.wiki)
	int x = 1, i = 0, j = 0;
	int a = 0;
	int y[N][2];
	int* e[N];
	printf("N: %i, pk: %i \n",N,pk);
	for (x = ceil(sqrt(N)); x <= N; x++) {
		a = (int) pow(x, 2) % N;
		x++;
		if (isBSmooth(a, pk)) {
			y[i][0] = x; // x
			y[i][1] = a; // p(x)
			e[i] = getPrimeFactors(a); // factors of a
			i++;
		}
	}
}

/**
 * Checks if x is B-smooth
 * e.g. isBSmooth(1620,5) == true
 * 1,620 has prime factorization 2^2 × 3^4 × 5; therefore 1,620 is
 * 5-smooth because none of its prime factors are greater than 5
 */
bool isBSmooth(long x, int B) {
	int* P = getPrimeFactors(x);
	int i;
	for (i = sizeof(P) / sizeof(int); i >= 0; i--) {
		if (*(P + i) > B)
			return false;
	}
	//free(P);
	return true;
}

/*
 * https://stackoverflow.com/questions/23287/largest-prime-factor-of-a-number
 * Runs O(sqrt(n))
 * @param n positive integer
 * @return All the prime factors of a positive integer n
 */
int* getPrimeFactors(int n) {
	int* factors = calloc(ceil(0.25 * n), sizeof(int));
	int d = 2, i = 0, ct = 0;
	while (n > 1) {
		while (n % d == 0) {
			*(factors + i) = d;
			n /= d;
			i++;
			if(d != 0) ct++;
		}
		d++;
		if (d * d > n) {
			if (n > 1) {
				*(factors + i) = n;
				i++;
				if(n != 0) ct++;
			}
			break;
		}
	}
	// this counts as dynamic array, right?
	int* fact = calloc(ct,sizeof(int));
	memcpy(fact,factors,ct);
	//free(factors);
	return fact;
}
/*
 * This is horrible style. I copied this from Problem7.c b/c I wanted to avoid
 * tripple-overloading
 * @returns all Primes <= limit
 */
int* getAllFromSieveOfEratosthenes(int limit) {
	limit--;
	const int UNMARKED = 1;
	const int MARKED = 0;
	long i = 0, j = 0, counter = 0;
	long size = limit * 100; // Not exactly accurate. Might need some refining
	int* primes = malloc(size * sizeof(int));
	int* res = malloc(size * sizeof(int));
	int lastPrime = 2;

	// start at 2. Set all as prime
	for (i = lastPrime; i < size; i++) {
		// this kills 32bit-OS, since j*i will exceed 2^(32)-1 pretty quickly
		*(primes + i) = UNMARKED;
	}
	*(primes + 2) = MARKED;
	i = lastPrime;
	// Starting from p^(2), enumerate its multiples by counting to n in increments of p, and mark them in the list
	do {
		for (j = i; (i * j) < size; j++) {
			*(primes + j * i) = MARKED;
		}
		// Find the first number greater than p in the list that is not marked
		for (j = lastPrime; j < size; j++) {
			if (j > lastPrime && *(primes + j) == UNMARKED) {
				// Let p now equal this new number
				i = lastPrime = j;
				// add to result
				*(res + counter) = i;
				// Increment prime-count
				counter++;
				break;
			}
		}
	} while (counter < limit);
	free(primes);
	return res;
}

	int bf = 0, ct = 0, imax = 0;
	int emax = sizeof(e) / sizeof(int);
	int* expMat[emax];
	for (i = 0; i < emax; i++) {
		imax = sizeof(e[i]) / sizeof(int);
		int v[imax][2];
		*(expMat+i) = v;
		for (j = 0; j < imax; i++) {
			// if the current exponent is still being counted, increment
			if(*(e[i]+i) == bf) {
				ct++;
			}
			// re-set the buffer and store the value in the exponent vector
			else {
				v[i][0] = bf;
				v[i][1] = ct;
				bf = *(e[i]+i);
				ct = 0;
			}
		}
	}