rename frac into rational

Author: indy256

cpp/numbertheory/frac.h

@@ -1,13 +1,15 @@
 #include <bits/stdc++.h>
-#include "frac.h"
+#include "rational.h"
 
 using namespace std;
-using fracll = frac<long long>;
+using rt = rational<long long/*__int128*/>;
 
 // usage example
 int main() {
-    fracll x{1, 2};
-    fracll y{2, 3};
+    rt x{1, 2};
+    rt y{2, 3};
+    if (y > x)
+        cout << "y > x" << endl;
     x -= y;
     x = x.abs();
     cout << x.a << "/" << x.b << endl;

cpp/numbertheory/frac.cpp renamed to cpp/numbertheory/rational.cpp

@@ -0,0 +1,76 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+template<class T>
+struct rational {
+    T a, b;
+
+    rational(T a, T b = 1) : a{a}, b{b} {
+        normalize();
+    }
+
+    void normalize() {
+        if (b < 0) {
+            a = -a;
+            b = -b;
+        }
+        auto g = gcd(::abs(a), b);
+        if (g != 0) {
+            a /= g;
+            b /= g;
+        }
+    }
+
+    bool operator==(rational rhs) const { return a == rhs.a && b == rhs.b; }
+
+    bool operator!=(rational rhs) const { return !(*this == rhs); }
+
+    bool operator<(rational rhs) const { return a * rhs.b < b * rhs.a; }
+
+    bool operator<=(rational rhs) const { return !(rhs < *this); }
+
+    bool operator>(rational rhs) const { return rhs < *this; }
+
+    bool operator>=(rational rhs) const { return !(*this < rhs); }
+
+    rational operator-() const { return rational(-a, b); }
+
+    rational abs() const { return rational(::abs(a), b); }
+
+    rational &operator+=(rational rhs) {
+        a = a * rhs.b + b * rhs.a;
+        b *= rhs.b;
+        normalize();
+        return *this;
+    }
+
+    rational &operator-=(rational rhs) {
+        a = a * rhs.b - b * rhs.a;
+        b *= rhs.b;
+        normalize();
+        return *this;
+    }
+
+    rational &operator*=(rational rhs) {
+        a *= rhs.a;
+        b *= rhs.b;
+        normalize();
+        return *this;
+    }
+
+    rational &operator/=(rational rhs) {
+        a *= rhs.b;
+        b *= rhs.a;
+        normalize();
+        return *this;
+    }
+
+    friend rational operator+(rational lhs, rational rhs) { return lhs += rhs; }
+
+    friend rational operator-(rational lhs, rational rhs) { return lhs -= rhs; }
+
+    friend rational operator*(rational lhs, rational rhs) { return lhs *= rhs; }
+
+    friend rational operator/(rational lhs, rational rhs) { return lhs /= rhs; }
+};