Есть ли класс для работы с дробными/смешанными числами?

#include <cmath>
 
namespace Math {
 
  /**
   * Calculates GCD of two objects with Euclidian division method.
   * Requres parameters to be comparable with "<" operator, and
   * to be substractable.
   * <p>
   * Returns 1 if either of parameters is zero.
   * 
   * @param a first object.
   * @param b second object.
   * @return value, representing GCD of two passed objects.
   */
  template <class ValueType>
  ValueType getGcd(ValueType a, ValueType b) {
    if (a == 0 || b ==0) {
      return 1;
    }
    if (a < 0) {
      a = -a;
    }
    if (b < 0) {
      b = -b;
    }
    while (a != b) {
      if (a < b) {
        b -= a;
      } else {
        a -= b;
      }
    }
    return a;
  }
 
  /**
   * Immutable class representing a fraction.
   * 
   * @param ValueType type of numerator and denominator, should be signed.
   */
  template <class ValueType = long int>
  class Fraction {
   public:
 
    /**
     * Default class constructor. Set fraction to 0/1.
     */
    Fraction() : numerator(0), denominator(1) {}
 
    /**
     * Class constructor with one parameter. Set fraction to value/1.
     * Is also used to convert ValueType to a fraction.
     * 
     * @param value value to set fraction to.
     */
    Fraction(const ValueType &value) : numerator(value), denominator(1) {}
 
    /**
     * Class constructor with two parameters. Sets fraction to
     * numerator/denominator.
     * 
     * @param numerator value of fraction numerator.
     * @param denominator value of fraction denomintator.
     */
    Fraction(const ValueType &numerator, const ValueType &denominator)
      : numerator(numerator), denominator(denominator) {}
 
    /**
     * Getter for numerator value.
     * 
     * @return value of fraction numerator.
     */
    const ValueType &getNumerator() const {
      return numerator;
    }
 
    /**
     * Getter for denominator value.
     * 
     * @return value of fraction denominator.
     */
    const ValueType &getDenominator() const {
      return denominator;
    }
   private:
    ValueType numerator;
    ValueType denominator;
  };
 
  /**
   * Reduces fraction, removing GCD from both numerator and
   * denominator and simplifying fraction sign.
   * 
   * @param fraction a fraction to reduce.
   * @return reference to self object.
   * @see Fraction
   */
  template <class T>
  Fraction<T> reduce(const Fraction<T> &fraction) {
    T gcd = getGcd(fraction.getNumerator(), fraction.getDenominator());
    T numerator = fraction.getNumerator() / gcd;
    T denominator = fraction.getDenominator() / gcd;
    if (denominator < 0) {
      numerator = -numerator;
      denominator = -denominator;
    }
    return Fraction<T>(numerator, denominator);
  }
 
  /**
   * Addition operator for two fractions.
   * 
   * @param a first component.
   * @param b second component.
   * @return a fraction that is a sum of two fractions. 
   */
  template <class T>
  Fraction<T> operator+(const Fraction<T> &a, const Fraction<T> &b) {
    return Fraction<T>(a.getNumerator() * b.getDenominator() +
      a.getDenominator() * b.getNumerator(),
      a.getDenominator() * b.getDenominator());
  }
 
  /**
   * Subtraction operator for two fractions.
   * 
   * @param a minuend fraction.
   * @param b subtrahend fraction.
   * @return a fraction that is a difference of two minuend and subtrahend.
   */
  template <class T>
  Fraction<T> operator-(const Fraction<T> &a, const Fraction<T> &b) {
    return Fraction<T>(a.getNumerator() * b.getDenominator() -
      a.getDenominator() * b.getNumerator(),
      a.getDenominator() * b.getDenominator());
  }
 
  /**
   * Multiplication of two fractions.
   * 
   * @param a first multiplier.
   * @param b second multiplier.
   * @return product of two multipliers.
   */
  template <class T>
  Fraction<T> operator*(const Fraction<T> &a, const Fraction<T> &b) {
    return Fraction<T>(a.getNumerator() * b.getNumerator(),
      a.getDenominator() * b.getDenominator());
  }
 
  /**
   * Division of two fractions.
   * 
   * @param a dividend fraction.
   * @param b divisor fraction.
   * @return a fraction that is a quotent of two divident and divisor.
   */
  template <class T>
  Fraction<T> operator/(const Fraction<T> &a, const Fraction<T> &b) {
    return Fraction<T>(a.getNumerator() * b.getDenominator(),
      a.getDenominator() * b.getNumerator());
  }
 
  /**
   * Negation operator for a fraction.
   * 
   * @param fraction a given fraction.
   * @return a fraction with an opposite sign.
   */
  template <class T>
  Fraction<T> operator-(const Fraction<T> &fraction) {
    return Fraction<T>(-fraction.getNumerator(), fraction.getDenominator());
  }
 
  /**
   * C-style comparision function for two fractions.
   * 
   * @param a left operand.
   * @param b right operand.
   * @return a negative value if left operand is greater, a zero if
   *         operands are equal and a positive value if right operand
   *         is greater.
   */
  template <class T>
  T compare(const Fraction<T> &a, const Fraction<T> &b) {
    return a.getNumerator() * b.getDenominator() - a.getDenominator() *
      b.getNumerator();
  }
 
  /**
   * Convinient operator to check if a fraction is less than another
   * fraction.
   * 
   * @param a left component.
   * @param b right component
   * @return true if left component is less than the right one.
   */
  template <class T>
  bool operator<(const Fraction<T> &a, const Fraction<T> &b) {
    return compare(a, b) < 0;
  }
 
  /**
   * Convinient operator to check if a fraction is less than or equal to
   * another fraction.
   * 
   * @param a left component.
   * @param b right component
   * @return true if left component is less than or equal to the right one.
   */
  template <class T>
  bool operator<=(const Fraction<T> &a, const Fraction<T> &b) {
    return compare(a, b) <= 0;
  }
 
  /**
   * Convinient operator to check if a fraction is greater than another
   * fraction.
   * 
   * @param a left component.
   * @param b right component
   * @return true if left component is greater than the right one.
   */
  template <class T>
  bool operator>(const Fraction<T> &a, const Fraction<T> &b) {
    return compare(a, b) > 0;
  }
 
  /**
   * Convinient operator to check if a fraction is greater than or equal to
   * another fraction.
   * 
   * @param a left component.
   * @param b right component
   * @return true if left component is greater than or equal to the right one.
   */
  template <class T>
  bool operator>=(const Fraction<T> &a, const Fraction<T> &b) {
    return compare(a, b) >= 0;
  }
 
  /**
   * Convinient operator to check if a fraction is equal to another fraction.
   * It uses the same compare function, since reducing may cause
   * performance issues.
   * 
   * @param a left component.
   * @param b right component
   * @return true if left component is equal to the right one.
   */
  template <class T>
  bool operator==(const Fraction<T> &a, const Fraction<T> &b) {
    return compare(a, b) == 0;
  }
 
  /**
   * Convinient operator to check if a fraction is not equal to another
   * fraction.
   * It uses the same compare function, since reducing may cause
   * performance issues.
   * 
   * @param a left component.
   * @param b right component
   * @return true if left component is not equal to the right one.
   */
  template <class T>
  bool operator!=(const Fraction<T> &a, const Fraction<T> &b) {
    return compare(a, b) != 0;
  }
 
  /**
   * Computes power of a fraction.
   * 
   * @param fraction fraction to get power of.
   * @param power power to return fraction in.
   * @return fraction in power of power.
   */
  template <class T>
  Fraction<T> pow(const Fraction<T> &fraction, const T &power) {
    // optimization for a common use case
    if (power == 0) {
      return 1;
    }
    Fraction<T> result(std::pow(fraction.getNumerator(), std::abs(power)),
        std::pow(fraction.getDenominator(), std::abs(power)));
    return ((power < 0) ? (Fraction<T>(1) / result) : result);
  }
 
  /**
   * Calculates absolute value of a fraction.
   * 
   * @param fraction a fraction.
   * @return a fraction that represent an absolute value of a fraction.
   */
  template <class T>
  Fraction<T> abs(const Fraction<T> &fraction) {
    return Fraction<T>(std::abs(fraction.getNumerator()),
      std::abs(fraction.getDenominator()));
  }
 
}

#include "Math/fraction.hpp"
#include <iostream>
 
template <class T>
std::ostream &operator<<(std::ostream &stream, const Math::Fraction<T> &fraction) {
  Math::Fraction<T> f = Math::reduce(fraction);
  return stream << f.getNumerator() << "/" << f.getDenominator();
}
 
int main(int argc, char *argv[]) {
  std::cout << "Simple math:" << std::endl;
 
  Math::Fraction<int> a(881, -7716), b(127, 343);
  std::cout << "a = " << a << ", b = " << b << std::endl;
  std::cout << "a - b = " << a - b << std::endl;
  std::cout << "a + b = " << a + b << std::endl;
  std::cout << "a * b = " << a * b << std::endl;
  std::cout << "a / b = " << a / b << std::endl;
  std::cout << "-a = " << -a << std::endl;
  std::cout << "a ^ 2 = " << pow(a, 2) << std::endl;
  std::cout << "a ^ -2 = " << pow(a, -2) << std::endl;
  std::cout << "abs(a) = " << abs(a) << std::endl;
 
  std::cout << "Comparisions:" << std::endl;
 
  std::cout << "a < b = " << ((a < b) ? "true" : "false") << std::endl;
  std::cout << "a <= b = " << ((a <= b) ? "true" : "false") << std::endl;
  std::cout << "a > b = " << ((a > b) ? "true" : "false") << std::endl;
  std::cout << "a >= b = " << ((a >= b) ? "true" : "false") << std::endl;
  std::cout << "a == b = " << ((a == b) ? "true" : "false") << std::endl;
  std::cout << "a != b = " << ((a != b) ? "true" : "false") << std::endl;
 
  return 0;
};