A naive procedure: Try all the numbers between [math2[/math and [math13980053[/math and repeat this recursively with all the found dividers until only prime dividers are left.This is not particularly efficient.
It becomes more efficient if we make two numerical-theoretical considerations:
- We only have to check up to [math-frac-n-2-[/math, because the smallest prime divider is [math2[/math.
(Alternatively, we could only check up to [math-sqrt-n-/math and for each divider [matha[/math the equivalent [math-frac-a-[/math), although we can still consider it. would have to take care of the prime factor decomposition of [math-frac-a-[/math), which does not necessarily make it more efficient.)
Only the prime dividers are important. Therefore, only the prime numbers up to [math-frac-n-2-[/math, whose density decreases as the number range under consideration increases, must be checked.
So we can increase the efficiency of the prime factor decomposition of n by first determining the prime numbers up to [math-frac-n-2-[/math and then trying them out.Possible methods for prime determination are the sieve of the erat host (simple) or the sieve of Atkin (slightly more complicated, but more efficient). I use the primerange function from sympy here. Here is not the most efficient, but at least an algorithm from me, which copes quite well with numbers down to the millions.
( c) Thomas Willberger-nfrom sympy import sieve-nfrom math import log nn = 13980053 ncandidates = [i for i in sieve.primerange(2, int(n/2+2))'nprimeFactors = dict()'n'n'n for candidate in candidates:'n if n% candidate== exponent-n-nif not primeFactors: " empty list, no prime factors"n print("Prime number!") *****lif len(primeFactors) == 1: prime factor is a single power key = list(primeFactors.keys())[0'n primeFactors[key = log(n) [ log(key)'nelse:'n prod = 1' current product of the prime factors'n for k in primeFactors.keys(:'n prod*= k'n' p = n / prod - number to check n while prod < n:n for factor in primeFactors.keys():n if p % factor == 0: n primeFactors[factor += 1 - prime factor exponent n p /= factor n prod *= factor
The runtime analysis gives the following picture – not all too bad:
For numbers around 100 million, the above algorithm takes 2-4 seconds.
This is, of course, a multiple of the time that sympy’s optimized factorint algorithm takes (fraction of a second).
However, a prime factor decomposition is of course also thick chunks and it is simply not known an efficient method for large prime numbers.Even the fastest known method, the square sieve, has a runtime complexity of [math-mathcal-O-(e-sqrt-ln n-cdot-ln-ln-ln-ln-n-)[math.But this is also a good thing, because encryptions such as RSA rely precisely on this fact by multiplying sufficiently large prime numbers (> 100 digits), from whose product the prime factors can be reconstructed very difficult and inefficiently (and thus a duration of months to years). If there were an efficient method of prime factor decomposition, RSA encryption would be gone.
And now the output for the number [math13980053[/math:
[math13980053[/math is therefore a prime number and cannot be further factoriable.