mmathlib/fractions.hpp

#pragma once
#include <iostream>
#include <string>

class fraction {
private:
  int64_t n = 0;
  int64_t d = 1;
  int64_t gcd(int64_t a, int64_t b) const {
    if (b == 0) {
      return a;
    }
    return gcd(b, a % b);
  }
  int get_precision(double a) {
    std::string s = std::to_string(a);
    int i = s.length() - 1;
    while (s[i] == '0') {
      i--;
    }
    s.erase(i + 1, s.length());
    bool point = false;
    int count = 0;
    for (long unsigned i = 0; i < s.length(); i++) {
      if (s[i] == '.') {
        point = true;
      } else {
        if (point) {
          count++;
        }
      }
    }
    return count;
  }

public:
  // Constructors
  fraction() {}
  fraction(const fraction &q) {
    int64_t hcf = gcd(q.n, q.d);
    n = q.n / hcf;
    d = q.d / hcf;
  }
  fraction(int64_t a, int64_t b) {
    int64_t hcf = gcd(a, b);
    n = a / hcf;
    d = b / hcf;
  }
  fraction(int a, int b) {
    int64_t hcf = gcd(a, b);
    n = (int64_t)a / hcf;
    d = (int64_t)b / hcf;
  }
  fraction(int a) {
    fraction q(a, 1);
    n = q.n;
    d = q.d;
  }
  fraction(double dec) {
    int precision = get_precision(dec);
    int64_t denominator = 1;
    for (int i = 0; i < precision; i++) {
      denominator *= 10;
    }
    int64_t numerator = dec * denominator;
    fraction q(numerator, denominator);
    n = q.n;
    d = q.d;
  }
  ~fraction() {}
  // Member functions
  int get_sign() const { return (!(n >= 0) != !(d >= 0)) ? -1 : 1; }
  int64_t get_n() const { return this->n; }
  int64_t get_d() const { return this->d; }
  double to_double() const {
    double dec = (double)n / (double)d;
    return dec;
  }
  // Operators
  fraction operator+(const fraction &that) const {
    int64_t numerator = this->n * that.d + that.n * this->d;
    int64_t denominator = this->d * that.d;
    fraction q(numerator, denominator);
    return q;
  }
  fraction operator-(const fraction &that) const {
    int64_t numerator = this->n * that.d - that.n * this->d;
    int64_t denominator = this->d * that.d;
    fraction q(numerator, denominator);
    return q;
  }
  fraction operator*(const fraction &that) const {
    int64_t numerator = this->n * that.n;
    int64_t denominator = this->d * that.d;
    fraction q(numerator, denominator);
    return q;
  }
  fraction operator*(const int i) const {
    int64_t numerator = this->n * i;
    int64_t denominator = this->d;
    fraction q(numerator, denominator);
    return q;
  }
  fraction operator/(const fraction &that) const {
    fraction a(this->n, this->d);
    fraction b(that.d, that.n);
    return a * b;
  }
  friend std::ostream &operator<<(std::ostream &os, const fraction &q) {
    int64_t num = q.n;
    int64_t den = q.d;
    std::string s = "";
    if (q.n < 0) {
      s = "-";
      num = num * -1;
    }
    if (q.d < 0) {
      s = "-";
      den = den * -1;
    }
    if (q.get_sign() == 1) {
      std::string s = "";
    }
    if (q.d == q.n) {
      os << s << 1;
    } else if (q.d == 1) {
      os << s << num;
    } else {
      os << s << '(' << num << '/' << den << ')';
    }
    return os;
  }
  void operator=(const fraction &q) {
    this->n = q.n;
    this->d = q.d;
  }
  void operator=(const int i) {
    this->n = (int64_t)i;
    this->d = (int64_t)1;
  }
  void operator=(const double dec) {
    const fraction q(dec);
    this->n = q.n;
    this->d = q.d;
  }
  bool operator>(const fraction &q) const {
    int64_t hcf = gcd(d, q.d);
    fraction a(*this * hcf);
    fraction b(q * hcf);
    return (a.n > b.n);
  }
  bool operator>(const int i) const {
    fraction q(i);
    return (*this > q);
  }
  bool operator==(const fraction &q) const {
    return ((this->n == q.n) && (this->d == q.d));
  }
  bool operator==(const int i) const {
    fraction q(i);
    return (*this == q);
  }
  bool operator==(const double dec) const {
    fraction q(dec);
    return (*this == q);
  }
  bool operator!=(const fraction &q) const {
    return ((n != q.n) || (d != q.d));
  }
  bool operator!=(const int i) const {
    fraction q(i);
    return (*this != q);
  }
  bool operator!=(const double dec) const {
    fraction q(dec);
    return (*this != q);
  }
};