Add article about integer factorization

jakobkogler · jakobkogler · commit 07bbf969bbc7 · 2019-03-16T23:59:51.000+01:00
This time without overwriting all primality/montgomery stuff.
diff --git a/img/pollard_rho.png b/img/pollard_rho.png
diff --git a/src/algebra/factorization.md b/src/algebra/factorization.md
diff --git a/src/algebra/montgomery_multiplication.md b/src/algebra/montgomery_multiplication.md
@@ -1,8 +1,7 @@
 <!--?title Montgomery Multiplication -->
 # Montgomery Multiplication
 
-Many algorithms in number theory, like [prime testing](./algebra/primality_tests.html) or factorization, and in cryptography, like RSA, require lots of operations modulo a large number.
-
+Many algorithms in number theory, like [prime testing](./algebra/primality_tests.html) or [integer factorization](./algebra/factorization.html), and in cryptography, like RSA, require lots of operations modulo a large number.
 A multiplications like $x y \bmod{n}$ is quite slow to compute with the typical algorithms, since it requires a division to know how many times $n$ has to be subtracted from the product.
 And division is a really expensive operation, especially with big numbers.
 
diff --git a/src/algebra/phi-function.md b/src/algebra/phi-function.md
@@ -57,7 +57,7 @@ int phi(int n) {
 }
 ```
 
-## Application in Euler's theorem
+## Application in Euler's theorem ## {#application}
 
 The most famous and important property of Euler's totient function is expressed in **Euler's theorem**: 
 $$a^{\phi(m)} \equiv 1 \pmod m$$ if $a$ and $m$ are relatively prime.
diff --git a/src/algebra/primality_tests.md b/src/algebra/primality_tests.md
@@ -26,6 +26,7 @@ bool isPrime(int x) {
 
 This is the simplest form of a prime check.
 You can optimize this function quite a bit, for instance by only checking all odd numbers in the loop, since the only even prime number is 2.
+Multiple such optimizations are described in the article about [integer factorization](./algebra/factorization.html).
 
 ## Fermat primality test
 
diff --git a/src/index.md b/src/index.md
@@ -21,6 +21,7 @@ and adding new articles to the collection.*
     - [Sieve of Eratosthenes](./algebra/sieve-of-eratosthenes.html)
     - [Sieve of Eratosthenes With Linear Time Complexity](./algebra/prime-sieve-linear.html)
     - [Primality tests](./algebra/primality_tests.html)
+    - [Integer factorization](./algebra/factorization.html)
 - **Number-theoretic functions**
     - [Euler's totient function](./algebra/phi-function.html)
     - [Number of divisors / sum of divisors](./algebra/divisors.html)
diff --git a/test/test_factorization.cpp b/test/test_factorization.cpp
@@ -0,0 +1,57 @@
+#include <vector>
+#include <cassert>
+#include <array>
+#include <map>
+using namespace std;
+
+long long power(long long b, long long e, long long mod) {
+    long long res = 1;
+    while (e) {
+        if (e & 1)
+            res = res * b % mod;
+        b = b * b % mod;
+        e >>= 1;
+    }
+    return res;
+}
+
+long long gcd(long long a, long long b) {
+    if (a == 0)
+        return b;
+    return gcd(b % a, a);
+}
+
+#include "../test/factorization_trial_division1.h"
+#include "../test/factorization_trial_division2.h"
+#include "../test/factorization_trial_division3.h"
+#include "../test/factorization_trial_division4.h"
+#include "../test/factorization_p_minus_1.h"
+#include "../test/pollard_rho.h"
+#include "../test/pollard_rho_brent.h"
+
+int main() {
+    map<long long, vector<long long>> test_data = {
+        {132, {2, 2, 3, 11}},
+        {123456789, {3, 3, 3607, 3803}},
+        {4817191, {1303, 3697}}
+    };
+    primes = {2, 3, 5, 7, 1303, 3607};
+
+    for (auto n_expected : test_data) {
+        auto n = n_expected.first;
+        auto expected = n_expected.second;
+
+        assert(trial_division1(n) == expected);
+        assert(trial_division2(n) == expected);
+        assert(trial_division3(n) == expected);
+        assert(trial_division4(n) == expected);
+
+        long long g = pollards_p_minus_1(n);
+        assert(g > 1 && g < n && n % g == 0);
+
+        g = rho(n);
+        assert(g > 1 && g < n && n % g == 0);
+        g = brent(n);
+        assert(g > 1 && g < n && n % g == 0);
+    }
+}
diff --git a/test/test_pollard_rho.cpp b/test/test_pollard_rho.cpp
@@ -0,0 +1,17 @@
+#include <cassert>
+#include <cmath>
+using namespace std;
+
+long long gcd(long long a, long long b) {
+    if (a == 0)
+        return b;
+    return gcd(b % a, a);
+}
+
+#include "pollard_rho.h"
+
+int main() {
+    long long n = 21471091LL * 38678789LL;
+    long long g = rho(n);
+    assert(g > 1 && g < n);
+}

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ int phi(int n) {`
`57`	`57`	`}`
`58`	`58`	```
`59`	`59`
`60`		`-## Application in Euler's theorem`
	`60`	`+## Application in Euler's theorem ## {#application}`
`61`	`61`
`62`	`62`	`The most famous and important property of Euler's totient function is expressed in Euler's theorem:`
`63`	`63`	`$$a^{\phi(m)} \equiv 1 \pmod m$$ if $a$ and $m$ are relatively prime.`