Restructured organization a bit

Author: Chillee

content/number-theory/ModularArithmetic.h

@@ -28,5 +28,5 @@ struct Mod {
 		Mod r = *this ^ (e / 2); r = r * r;
 		return e&1 ? *this * r : r;
 	}
-	explicit operator ll(){ return x; }
+	explicit operator ll() const { return x; }
 };

content/numerical/PolynomialBase.h renamed to content/numerical/PolyBase.h

@@ -12,11 +12,6 @@
 
 typedef Mod num;
 typedef vector<num> poly;
-vector<Mod> conv(vector<Mod> a, vector<Mod> b) {
-	auto res = convMod<mod>(vl(all(a)), vl(all(b)));
-	// auto res = conv(vl(all(a)), vl(all(b)));
-	return vector<Mod>(all(res));
-}
 poly &operator+=(poly &a, const poly &b) {
 	a.resize(max(sz(a), sz(b)));
 	rep(i, 0, sz(b)) a[i] = a[i] + b[i];
@@ -35,7 +30,9 @@ poly &operator*=(poly &a, const poly &b) {
 			res[i + j] = (res[i + j] + a[i] * b[j]);
 		return (a = res);
 	}
-	return a = conv(a, b);
+	auto res = convMod<mod>(vl(all(a)), vl(all(b)));
+	// auto res = conv(vl(all(a)), vl(all(b)));
+	return (a = poly(all(res)));
 }
 poly operator*(poly a, const num b) {
 	poly c = a;
@@ -45,7 +42,7 @@ poly operator*(poly a, const num b) {
 #define OP(o, oe) \
 	poly operator o(poly a, poly b) { \
 		poly c = a; \
-		return c oe b; \
+		return c o##= b; \
 	}
 OP(*, *=) OP(+, +=) OP(-, -=);
 poly modK(poly a, int k) { return {a.begin(), a.begin() + min(k, sz(a))}; }

content/numerical/PolynomialEval.h renamed to content/numerical/PolyEvaluate.h

@@ -1,6 +1,12 @@
+/**
+ * Author: chilli, Andrew He, Adamant
+ * Date: 2019-04-27
+ * Description: Multi-point evaluation. Evaluates a given polynomial A at $A(x_0), ... A(x_n)$.
+ * Time: O(n \log^2 n)
+ */
 #pragma once
 
-#include "PolynomialMod.h"
+#include "PolyMod.h"
 
 vector<num> eval(const poly &a, const vector<num> &x) {
 	int n = sz(x);

content/numerical/PolyInterpolate.h

@@ -1,25 +1,22 @@
 /**
- * Author: Simon Lindholm
- * Date: 2017-05-10
- * License: CC0
- * Source: Wikipedia
- * Description: Given $n$ points (x[i], y[i]), computes an n-1-degree polynomial $p$ that
- *  passes through them: $p(x) = a[0]*x^0 + ... + a[n-1]*x^{n-1}$.
- *  For numerical precision, pick $x[k] = c*\cos(k/(n-1)*\pi), k=0 \dots n-1$.
- * Time: O(n^2)
+ * Author: chilli, Andrew He, Adamant
+ * Date: 2019-04-27
+ * Description: A FFT based Polynomial class.
  */
 #pragma once
 
-typedef vector<double> vd;
-vd interpolate(vd x, vd y, int n) {
-	vd res(n), temp(n);
-	rep(k,0,n-1) rep(i,k+1,n)
-		y[i] = (y[i] - y[k]) / (x[i] - x[k]);
-	double last = 0; temp[0] = 1;
-	rep(k,0,n) rep(i,0,n) {
-		res[i] += y[k] * temp[i];
-		swap(last, temp[i]);
-		temp[i] -= last * x[k];
-	}
-	return res;
-}
+#include "PolyMod.h"
+#include "PolyPow.h"
+#include "PolyEvaluate.h"
+
+poly interp(vector<num> x, vector<num> y) {
+	int n=sz(x);
+	vector<poly> up(n*2);
+	rep(i,0,n) up[i+n] = poly({num(0)-x[i], num(1)});
+	for(int i=n-1; i>0;i--) up[i] = up[2*i]*up[2*i+1];
+	vector<num> a = eval(deriv(up[1]), x);
+	vector<poly> down(2*n);
+	rep(i,0,n) down[i+n] = poly({y[i]*(num(1)/a[i])});
+	for(int i=n-1;i>0;i--) down[i] = down[i*2] * up[i*2+1] + down[i*2+1] * up[i*2];
+	return down[1];
+}

content/numerical/PolyInterpolateSlow.h

@@ -0,0 +1,25 @@
+/**
+ * Author: Simon Lindholm
+ * Date: 2017-05-10
+ * License: CC0
+ * Source: Wikipedia
+ * Description: Given $n$ points (x[i], y[i]), computes an n-1-degree polynomial $p$ that
+ *  passes through them: $p(x) = a[0]*x^0 + ... + a[n-1]*x^{n-1}$.
+ *  For numerical precision, pick $x[k] = c*\cos(k/(n-1)*\pi), k=0 \dots n-1$.
+ * Time: O(n^2)
+ */
+#pragma once
+
+typedef vector<double> vd;
+vd interpolate(vd x, vd y, int n) {
+	vd res(n), temp(n);
+	rep(k,0,n-1) rep(i,k+1,n)
+		y[i] = (y[i] - y[k]) / (x[i] - x[k]);
+	double last = 0; temp[0] = 1;
+	rep(k,0,n) rep(i,0,n) {
+		res[i] += y[k] * temp[i];
+		swap(last, temp[i]);
+		temp[i] -= last * x[k];
+	}
+	return res;
+}

content/numerical/PolynomialMod.h renamed to content/numerical/PolyMod.h

@@ -1,6 +1,11 @@
+/**
+ * Author: chilli, Andrew He, Adamant
+ * Date: 2019-04-27
+ * Description: A FFT based Polynomial class.
+ */
 #pragma once
 
-#include "PolynomialBase.h"
+#include "PolyBase.h"
 
 poly &operator/=(poly &a, poly b) {
 	if (sz(a) < sz(b))

content/numerical/PolynomialPow.h renamed to content/numerical/PolyPow.h

@@ -1,6 +1,11 @@
+/**
+ * Author: chilli, Andrew He, Adamant
+ * Date: 2019-04-27
+ * Description: A FFT based Polynomial class.
+ */
 #pragma once
 
-#include "PolynomialBase.h"
+#include "PolyBase.h"
 poly deriv(poly a) {
 	if (a.empty())
 		return {};

content/numerical/PolynomialInterpolate.h

@@ -1,7 +1,11 @@
 \chapter{Numerical}
 
 \kactlimport{GoldenSectionSearch.h}
-\kactlimport{PolynomialBase.h}
+\kactlimport{PolyBase.h}
+\kactlimport{PolyMod.h}
+\kactlimport{PolyPow.h}
+\kactlimport{PolyInterpolate.h}
+\kactlimport{PolyEvaluate.h}
 \kactlimport{PolyRoots.h}
 \kactlimport{BerlekampMassey.h}
 \kactlimport{LinearRecurrence.h}

content/numerical/chapter.tex

@@ -412,13 +412,17 @@ struct Mod {
 		Mod r = *this ^ (e / 2); r = r * r;
 		return e&1 ? *this * r : r;
 	}
-    explicit operator ll() { return x; }
+    explicit operator ll() const { return x; }
 };
 
 typedef Mod num;
 typedef vector<num> poly;
 
-#include "../../content/numerical/FFTPolynomial.h"
+#include "../../content/numerical/PolyBase.h"
+#include "../../content/numerical/PolyMod.h"
+#include "../../content/numerical/PolyPow.h"
+#include "../../content/numerical/PolyEvaluate.h"
+#include "../../content/numerical/PolyInterpolate.h"
 } // namespace mine
 
 pair<mine::poly, MIT::poly> genVec(int sz) {