x011.h

Go to the documentation of this file.

#pragma once

#include "xerror.h"
#include "xtools.h"
#include <algorithm>
#include <cmath>
#include <ctime>
#include <iostream>
#include <numeric>
#include <string>
#include <sstream>
#include <tuple>
#include <type_traits>
#include <vector>

namespace nmx::apps::x011 {

class Rational
{
private:
    long long _num, _den;

public:
    inline Rational(long long n = 0, long long d = 1)
        : _num{ n }
        , _den{ d } {
        if (d == 0) {
            throw std::domain_error(__func__);
        }
        if (d < 0) {
            _num *= -1;
            _den *= -1;
        }
    }

    inline auto num() const { return _num; }

    inline auto den() const { return _den; }

    inline void simplify() {
        long gcd = std::gcd(_num, _den);
        _num /= gcd;
        _den /= gcd;
    }

    explicit operator double() const { //
        return static_cast<double>(_num) / static_cast<double>(_den);
    }

    template<class T>
    static constexpr bool is_int_like_v = //
        (std::is_arithmetic_v<T> &&std::is_integral_v<T> //
         && !std::is_same_v<T, bool> && !std::is_same_v<T, char>);

    // Test : ist T eine ganze oder eine rationale Zahl
    template<class T>
    static constexpr bool is_rational_like_v = //
        is_int_like_v<T> || std::is_same_v<T, Rational>;

    template<class T, std::enable_if_t<is_rational_like_v<T>> * = nullptr>
    inline Rational &operator+=(const T &r) {
        if constexpr (is_int_like_v<T>) {
            _num = _num + _den;
        } else {
            _num = _num * r._den + r._num * _den;
            _den = _den * r._den;
        }
        simplify();
        return *this;
    }

    template<class T, std::enable_if_t<is_rational_like_v<T>> * = nullptr>
    inline Rational &operator-=(const T &r) {
        if constexpr (is_int_like_v<T>) {
            _num = _num - _den;
        } else {
            _num = _num * r._den - r._num * _den;
            _den = _den * r._den;
        }
        simplify();
        return *this;
    }

    template<class T, std::enable_if_t<is_rational_like_v<T>> * = nullptr>
    inline Rational &operator*=(const T &r) {
        if constexpr (is_int_like_v<T>) {
            _num = _num * r;
        } else {
            _num *= r._num;
            _den *= r._den;
        }
        simplify();
        return *this;
    }

    template<class T, std::enable_if_t<is_rational_like_v<T>> * = nullptr>
    inline Rational &operator/=(const T &r) {
        if (r.num() == 0) {
            throw std::overflow_error("operator/=");
        }
        if constexpr (is_int_like_v<T>) {
            _den *= r;
        } else {
            _num *= r._den;
            _den *= r._num;
        }
        return *this;
    }

    template<class X, class Y, class FN>
    inline friend auto helpfn(const X &arg1, const Y &arg2, FN fn) {
        //wenn eine der beiden Zahlen eine Fließkommazahl ist
        if constexpr (std::is_floating_point_v<X> || //
                      std::is_floating_point_v<Y>) {
            //...ist das Ergebnis auch eine Fließkommazahl
            double rout = static_cast<double>(arg1);
            fn(rout, static_cast<double>(arg2));
            return rout;
        } else {
            Rational rout{ arg1 };
            fn(rout, Rational{ arg2 });
            rout.simplify();
            return rout;
        }
    }

    template<class X, class Y>
    using is_candidate_t = //
        std::enable_if_t<std::is_same_v<X, Rational> || std::is_same_v<Y, Rational>>;

    template<class X, class Y, is_candidate_t<X, Y> * = nullptr>
    inline friend auto operator+(const X &x, const Y &y) {
        return helpfn(x, y, [](auto &a, const auto &b) { a += b; });
    }

    template<class X, class Y, is_candidate_t<X, Y> * = nullptr>
    inline friend auto operator-(const X &x, const Y &y) {
        return helpfn(x, y, [](auto &a, const auto &b) { a -= b; });
    }

    template<class X, class Y, is_candidate_t<X, Y> * = nullptr>
    inline friend auto operator*(const X &x, const Y &y) {
        return helpfn(x, y, [](auto &a, const auto &b) { a *= b; });
    }

    template<class X, class Y, is_candidate_t<X, Y> * = nullptr>
    inline friend auto operator/(const X &x, const Y &y) {
        return helpfn(x, y, [](auto &a, const auto &b) { a /= b; });
    }

    template<typename X, typename Y, is_candidate_t<X, Y> * = nullptr>
    inline friend bool operator==(const X &x, const Y &y) { //
        if constexpr (std::is_same_v<X, Y>) {
            //beide Eingabeargumente sind rationale Zahlen
            return x.num() * y.den() == x.den() * y.num();
        } else if constexpr (std::is_same_v<Y, Rational>) {
            return x * y.den() == y.num();
        } else {
            return x.num() == x.den() * y;
        }
    }

    template<class X, class Y, is_candidate_t<X, Y> * = nullptr>
    inline friend bool operator!=(const X &r1, const Y &r2) { //
        return !(r1 == r2);
    }

    template<class T>
    inline friend auto pow(const Rational &r, T n) { //
        if constexpr (std::is_same_v<T, int>) {
            Rational r1 = n > 0 ? r : inverse(r);
            long long num = //
                static_cast<long long>(std::pow(r1.num(), n));
            long long den = //
                static_cast<long long>(std::pow(r1.den(), n));
            return Rational{ num, den };
        } else {
            return std::pow(static_cast<double>(r), static_cast<double>(n));
        }
    }

    inline friend Rational inverse(const Rational &r) { //
        return Rational(r.den(), r.num());
    }

    inline friend Rational operator-(const Rational &r) { //
        return Rational(-r.num(), r.den());
    }

    inline friend std::ostream &operator<<(std::ostream &os, const Rational &r) {
        return os << r.num() << "/" << r.den();
    }
}; //Rational

inline void ex1() {
    Rational r1{ 1, 2 }, r2{ 1, 3 };
    auto rout = r1 + r2;
    std::cout << r1 << "+" << r2 << "=" << rout << std::endl;
    rout = r1 - r2;
    std::cout << r1 << "-" << r2 << "=" << rout << std::endl;
    rout = r1 * r2;
    std::cout << r1 << "*" << r2 << "=" << rout << std::endl;
    rout = r1 / r2;
    std::cout << r1 << "/" << r2 << "=" << rout << std::endl;
    Rational r5 = r1;
    r5 += 1;
    std::cout << r5 << std::endl;
}

inline void ex2() {
    Rational r3{ 5, 100 };
    std::cout << r3 << std::endl;
    r3.simplify();
    std::cout << "simplified:" << r3 << std::endl;
    std::cout << "as double:" << static_cast<double>(r3) << std::endl;
}

inline void ex3() {
    Rational r4{ 2, 4 };

    //Ausgabe der bool'schen Werte
    std::cout << std::boolalpha << (r4 == Rational{ 1, 2 }) << std::endl;
    std::cout << std::boolalpha << (r4 != Rational{ 3, 4 }) << std::endl;
    std::cout << std::boolalpha << (r4 == 0.5) << std::endl;
}

inline void ex4() {
    Rational r4{ 2, 4 };
    std::cout << pow(r4, 3) << std::endl;
    std::cout << pow(r4, 3.1) << std::endl;
}

inline void ex5() {
    Rational sum{ 0, 1 };

    for (long idx = 1; idx <= 8; idx++) {
        sum += Rational{ 1, idx };
    }

    std::cout << sum << std::endl;
    std::cout << static_cast<double>(sum) << std::endl;
}

inline void ex6() {
    Rational r1{ 5, 100 };

    auto c = r1 + 0.8;
    auto c1 = 1.1 + Rational{ 2, 2 };

    std::cout << c << std::endl;
    std::cout << c1 << std::endl;
}

} // namespace nmx::apps::x011