rationalg.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2023 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_RATIONALG
#define GEOGRAM_BASIC_RATIONALG
 
#include <geogram/basic/common.h>
#include <geogram/basic/numeric.h>
 
namespace GEO {
 
    template <class T> class rationalg {
    public:
        typedef T value_type;
 
        rationalg() = default;
 
        explicit rationalg(double x) : num_(x), denom_(1.0) {
        }
 
        explicit rationalg(const T& x) : num_(x), denom_(1.0) {
        }
 
        explicit rationalg(T&& x) : num_(x), denom_(1.0) {
        }
 
        explicit rationalg(double num, double denom)
            : num_(num), denom_(denom) {
        }
 
        explicit rationalg(const T& num, const T& denom)
            : num_(num), denom_(denom) {
        }
 
        explicit rationalg(
            T&& num, T&& denom
        ) : num_(num), denom_(denom) {
        }
 
        rationalg(const rationalg<T>& rhs) = default;
 
        rationalg(rationalg<T>&& rhs) = default;
 
        rationalg<T>& operator= (const rationalg<T>& rhs) = default;
 
        rationalg<T>& operator= (rationalg<T>&& rhs) = default;
 
        const T& num() const {
            return num_;
        }
 
        const T& denom() const {
            return denom_;
        }
 
        T& num() {
            return num_;
        }
 
        T& denom() {
            return denom_;
        }
 
        void optimize() {
            Numeric::optimize_number_representation(num_);
            Numeric::optimize_number_representation(denom_);
        }
 
        /********************************************************************/
 
        rationalg<T>& operator+= (const rationalg<T>& rhs) {
            if(has_same_denom(rhs)) {
                num_ += rhs.num_;
            } else {
                num_ = num_ * rhs.denom_ + rhs.num_ * denom_;
                denom_ *= rhs.denom_;
            }
            return *this;
        }
 
        rationalg<T>& operator-= (const rationalg<T>& rhs) {
            if(has_same_denom(rhs)) {
                num_ -= rhs.num_;
            } else {
                num_ = num_ * rhs.denom_ - rhs.num_ * denom_;
                denom_ *= rhs.denom_;
            }
            return *this;
        }
 
        rationalg<T>& operator*= (const rationalg<T>& rhs) {
            num_ *= rhs.num_;
            denom_ *= rhs.denom_;
            return *this;
        }
 
        rationalg<T>& operator/= (const rationalg<T>& rhs) {
            num_ *= rhs.denom_;
            denom_ *= rhs.num_;
            return *this;
        }
 
        rationalg<T>& operator+= (double rhs) {
            num_ += denom_ * T(rhs);
            return *this;
        }
 
        rationalg<T>& operator-= (double rhs) {
            num_ -= denom_ * T(rhs);
            return *this;
        }
 
        rationalg<T>& operator*= (double rhs) {
            num_ *= T(rhs);
            return *this;
        }
 
        rationalg<T>& operator/= (double rhs) {
            denom_ *= T(rhs);
            return *this;
        }
 
        /********************************************************************/
 
        rationalg<T> operator+ (const rationalg<T>& rhs) const {
            if(has_same_denom(rhs)) {
                return rationalg(
                    num_ + rhs.num_,
                    denom_
                );
            }
            return rationalg(
                num_ * rhs.denom_ + rhs.num_ * denom_,
                denom_ * rhs.denom_
            );
        }
 
        rationalg<T> operator- (const rationalg<T>& rhs) const {
            if(has_same_denom(rhs)) {
                return rationalg(
                    num_ - rhs.num_,
                    denom_
                );
            }
            return rationalg(
                num_ * rhs.denom_ - rhs.num_ * denom_,
                denom_ * rhs.denom_
            );
        }
 
        rationalg<T> operator* (const rationalg<T>& rhs) const {
            return rationalg(
                num_ * rhs.num_,
                denom_ * rhs.denom_
            );
        }
 
        rationalg<T> operator/ (const rationalg<T>& rhs) const {
            return rationalg(
                num_ * rhs.denom_,
                denom_ * rhs.num_
            );
        }
 
 
        rationalg<T> operator+ (double rhs) const {
            return rationalg(
                num_ + T(rhs) * denom_,
                denom_
            );
        }
 
        rationalg<T> operator- (double rhs) const {
            return rationalg(
                num_ - T(rhs) * denom_,
                denom_
            );
        }
 
        rationalg<T> operator* (double rhs) const {
            return rationalg(
                num_ * T(rhs),
                denom_
            );
        }
 
        rationalg<T> operator/ (double rhs) const {
            return rationalg(
                num_,
                denom_* T(rhs)
            );
        }
 
        /********************************************************************/
 
        rationalg<T> operator- () const {
            return rationalg(
                -num_,
                denom_
            );
        }
 
        /********************************************************************/
 
        Sign sign() const {
            geo_debug_assert(denom_.sign() != ZERO);
            return Sign(num_.sign() * denom_.sign());
        }
 
        /********************************************************************/
 
        Sign compare(const rationalg<T>& rhs) const {
            if(sign() != rhs.sign()){
                return Sign(sign()-rhs.sign());
            }
            if(has_same_denom(rhs)) {
                return Sign(num_.compare(rhs.num_) * denom_.sign());
            }
            return Sign(
                (num_ * rhs.denom_).compare(rhs.num_ * denom_) *
                denom_.sign() * rhs.denom_.sign()
            );
        }
 
        Sign compare(double rhs) const {
            return Sign(
                num_.compare(T(rhs)*denom_) * denom_.sign()
            );
        }
 
        bool operator> (const rationalg<T>& rhs) const {
            return (int(compare(rhs))>0);
        }
 
        bool operator>= (const rationalg<T>& rhs) const {
            return (int(compare(rhs))>=0);
        }
 
        bool operator< (const rationalg<T>& rhs) const {
            return (int(compare(rhs))<0);
        }
 
        bool operator<= (const rationalg<T>& rhs) const {
            return (int(compare(rhs))<=0);
        }
 
        bool operator> (double rhs) const {
            return (int(compare(rhs))>0);
        }
 
        bool operator>= (double rhs) const {
            return (int(compare(rhs))>=0);
        }
 
        bool operator< (double rhs) const {
            return (int(compare(rhs))<0);
        }
 
        bool operator<= (double rhs) const {
            return (int(compare(rhs))<=0);
        }
 
        /********************************************************************/
 
        double estimate() const {
            return num_.estimate() / denom_.estimate();
        }
 
    protected:
        void copy(const rationalg<T>& rhs) {
            num_ = rhs.num_;
            denom_ = rhs.denom_;
        }
 
        bool has_same_denom(const rationalg<T>& rhs) const {
            return denom_ == rhs.denom_;
        }
 
    private:
        T num_;
        T denom_;
    };
 
    /**************************************************************************/
 
    template <class T>
    inline rationalg<T> operator+ (double a, const rationalg<T>& b) {
        return b + a;
    }
 
    template <class T>
    inline rationalg<T> operator- (double a, const rationalg<T>& b) {
        rationalg<T> result = b - a;
        result.num().negate();
        return result;
    }
 
    template <class T>
    inline rationalg<T> operator* (double a, const rationalg<T>& b) {
        return b * a;
    }
 
    template <class T>
    inline rationalg<T> operator/ (double a, const rationalg<T>& b) {
        return rationalg<T>(
            T(a)*b.denom(),
            b.num()
        );
    }
 
    template <class T>
    inline bool operator== (const rationalg<T>& a, const rationalg<T>& b) {
        return (a.compare(b) == ZERO);
    }
 
    template <class T>
    inline bool operator== (const rationalg<T>& a, double b) {
        return (a.compare(b) == ZERO);
    }
 
    template <class T>
    inline bool operator== (double a, const rationalg<T>& b) {
        return (b.compare(a) == ZERO);
    }
 
    template <class T>
    inline bool operator!= (const rationalg<T>& a, const rationalg<T>& b) {
        return (a.compare(b) != ZERO);
    }
 
    template <class T>
    inline bool operator!= (const rationalg<T>& a, double b) {
        return (a.compare(b) != ZERO);
    }
 
    template <class T>
    inline bool operator!= (double a, const rationalg<T>& b) {
        return (b.compare(a) != ZERO);
    }
 
    /**************************************************************************/
 
    template <class T> inline Sign geo_sgn(const rationalg<T>& x) {
        return x.sign();
    }
 
    template <class T> inline Sign geo_cmp(
        const rationalg<T>& a, const rationalg<T>& b
    ) {
        return a.compare(b);
    }
 
    namespace Numeric {
 
        template <class T> inline void optimize_number_representation(
            rationalg<T>& x
        ) {
            x.optimize();
        }
 
    }
 
    /**************************************************************************/
 
    template <class T> struct is_scalar<rationalg<T> > {
        typedef rationalg<T> type;
        static constexpr bool value = true;
    };
 
}
 
#endif