arithmetic.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//arithmetic.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//arithmetic.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with arithmetic.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING.  Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.
 
// arithmetic.hpp:  Declares the arithmetic nodes for bertini2.

 
#ifndef BERTINI_OPERATOR_ARITHMETIC_HPP
#define BERTINI_OPERATOR_ARITHMETIC_HPP
 
#include <vector>
#include <string>
 
#include "bertini2/function_tree/node.hpp"
 
#include "bertini2/function_tree/operators/operator.hpp"
 
 
 
#include "bertini2/function_tree/symbols/number.hpp"
#include "bertini2/function_tree/symbols/special_number.hpp"
#include "bertini2/function_tree/symbols/variable.hpp"
#include "bertini2/function_tree/symbols/differential.hpp"
 
#include "bertini2/function_tree/forward_declares.hpp"
#include "bertini2/function_tree/canonical.hpp"
 
#include <cmath>
 
 
 
 
 
 
 
 
namespace bertini {
 
namespace node{
    class SumOperator : public NaryOperator
    {
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        virtual ~SumOperator() = default;
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;

        template<typename... Ts>
        static
        std::shared_ptr<SumOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<SumOperator>(Intern(std::shared_ptr<Node>( new SumOperator(ts...) )));
        }
 
    private:
        SumOperator(const std::shared_ptr<Node> & s, bool add_or_sub)
        {
            AddOperand(s, add_or_sub);
        }
 
        SumOperator(const std::shared_ptr<Node> & left, const std::shared_ptr<Node> & right)
        {
            AddOperand(left);
            AddOperand(right);
            CanonicalizeNaryOperands(operands_, signs_, false);
        }
 
 
        SumOperator(const std::shared_ptr<Node> & left, bool add_or_sub_left, const std::shared_ptr<Node> & right, bool add_or_sub_right)
        {
            AddOperand(left, add_or_sub_left);
            AddOperand(right, add_or_sub_right);
            CanonicalizeNaryOperands(operands_, signs_, false);
        }
 
        // Build a complete sum from a full (term, sign) list.  The node is fully constructed
        // before Make() interns it -- so callers never AddOperand AFTER Make (which, with interning,
        // could mutate a shared interned node).
        explicit SumOperator(std::vector<std::pair<std::shared_ptr<Node>, bool>> const& terms)
        {
            for (auto const& t : terms)
                AddOperand(t.first, t.second);
            CanonicalizeNaryOperands(operands_, signs_, false);
        }
 
    public:

        SumOperator& operator+=(const std::shared_ptr<Node> & rhs)
        {
            this->AddOperand(rhs);
            return *this;
        }

        SumOperator& operator-=(const std::shared_ptr<Node> & rhs)
        {
            this->AddOperand(rhs,false);
            return *this;
        }
 
 
 
 

        void AddOperand(std::shared_ptr<Node> child) override
        {
            NaryOperator::AddOperand(std::move(child));
            signs_.push_back(true);
        }
 

        void AddOperand(std::shared_ptr<Node> child, bool sign) // not an override
        {
            NaryOperator::AddOperand(std::move(child));
            signs_.push_back(sign);
        }
 

        void print(std::ostream & target) const override;
 
        unsigned Precedence() const override
        {
            return PrecSum;
        }
 
 
 

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;

        int Degree(std::shared_ptr<Variable> const& v = nullptr) const override;
 
 
        int Degree(VariableGroup const& vars) const override;

        std::vector<int> MultiDegreeImpl(VariableGroup const& vars) const override;

        inline
        const auto& GetSigns() const{ return this-> signs_;}
 
 

        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;
        std::size_t HashImpl() const override;
        bool IsSame(Node const& other) const override;
 
        bool IsHomogeneous(std::shared_ptr<Variable> const& v = nullptr) const override;

        bool IsHomogeneous(VariableGroup const& vars) const override;
 
 
 
 
 
 
    protected:
 
 
 
 
 
    private:
        // Stores the sign of the particular term.  There is a one-one
        // correspondence between elements of signs_ and operand_.  This
        // is enforced by the AddOperand method below, redefined in SumOperator.
 
        // TODO(JBC): If we add method to delete child, must also delete signs_ entry.
        std::vector<bool> signs_;
 
    private:
 
        SumOperator() = default;
 
        friend class boost::serialization::access;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<NaryOperator>(*this);
            ar & signs_;
        }
 
 
        void PrecisionChangeSpecific(unsigned prec) const override
        {
            temp_mp_.precision(prec);
        }
 
        mutable complex_mp temp_mp_;
        mutable complex_dbl temp_d_;
 
        friend MultOperator;
    };
 
 
 
 
 
 
 
 
 
 
 
 
 

    class NegateOperator : public UnaryOperator
    {
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        
        template<typename... Ts>
        static
        std::shared_ptr<NegateOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<NegateOperator>(Intern(std::shared_ptr<Node>( new NegateOperator(ts...) )));
        }
 
    private:
 
        NegateOperator(const std::shared_ptr<Node> & N) : UnaryOperator(N)
        {};
 
    public:
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;
        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;

        void print(std::ostream & target) const override;
 
        unsigned Precedence() const override
        {
            return PrecNegate;
        }
 

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;

        int Degree(std::shared_ptr<Variable> const& v = nullptr) const override
        {
            return operand_->Degree(v);
        }

        int Degree(VariableGroup const& vars) const override
        {
            return operand_->Degree(vars);
        }
 
        bool IsHomogeneous(std::shared_ptr<Variable> const& v = nullptr) const override
        {
            return operand_->IsHomogeneous(v);
        }

        bool IsHomogeneous(VariableGroup const& vars) const override
        {
            return operand_->IsHomogeneous(vars);
        }
 
        virtual ~NegateOperator() = default;
 
    protected:
 
 
 
 
    private:
 
        NegateOperator() = default;
 
        friend class boost::serialization::access;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<UnaryOperator>(*this);
        }
    };
 

    inline std::shared_ptr<Node> operator-(const std::shared_ptr<Node> & rhs)
    {
        return NegateOperator::Make(rhs);
    }
 
 
 
 
 
 
 
 
 
 

    class MultOperator : public NaryOperator
    {
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;
 

        template<typename... Ts>
        static
        std::shared_ptr<MultOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<MultOperator>(Intern(std::shared_ptr<Node>( new MultOperator(ts...) )));
        }
 
    private:
        MultOperator(std::shared_ptr<Node> const& s)
        {
            AddOperand(s);
        }
 
        MultOperator(std::shared_ptr<Node> const& left, std::shared_ptr<Node> const& right)
        {
            AddOperand(left);
            AddOperand(right);
            CanonicalizeNaryOperands(operands_, mult_or_div_, true);
        }
 
 
        MultOperator(const std::shared_ptr<Node> & left, bool mult_or_div_left, const std::shared_ptr<Node> & right, bool mult_or_div_right)
        {
            AddOperand(left, mult_or_div_left);
            AddOperand(right, mult_or_div_right);
            CanonicalizeNaryOperands(operands_, mult_or_div_, true);
        }
 
        // Build a complete product from a full (factor, mult-or-div) list -- fully constructed
        // before Make() interns it, so no post-Make AddOperand on a shared interned node.
        explicit MultOperator(std::vector<std::pair<std::shared_ptr<Node>, bool>> const& factors)
        {
            for (auto const& f : factors)
                AddOperand(f.first, f.second);
            CanonicalizeNaryOperands(operands_, mult_or_div_, true);
        }
 
    public:
 
        virtual ~MultOperator() = default;
 
 
 
 
        //Special Behaviour: by default all factors are in numerator
        void AddOperand(std::shared_ptr<Node> child) override
        {
            NaryOperator::AddOperand(std::move(child));
            mult_or_div_.push_back(true);
        }
 
 

        //Special Behaviour: Pass bool to set sign of term: true = mult, false = divide
        void AddOperand(std::shared_ptr<Node> child, bool mult) // not an override
        {
            NaryOperator::AddOperand(std::move(child));
            mult_or_div_.push_back(mult);
        }
 

        void print(std::ostream & target) const override;
 
        unsigned Precedence() const override
        {
            return PrecMult;
        }

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;

        int Degree(std::shared_ptr<Variable> const& v = nullptr) const override;
 
 
        int Degree(VariableGroup const& vars) const override;

        std::vector<int> MultiDegreeImpl(VariableGroup const& vars) const override;
 
 
        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;
        std::size_t HashImpl() const override;
        bool IsSame(Node const& other) const override;
 
        bool IsHomogeneous(std::shared_ptr<Variable> const& v = nullptr) const override;

        bool IsHomogeneous(VariableGroup const& vars) const override;

        inline
        const auto& GetMultOrDiv() const{ return this->mult_or_div_;}
 
    protected:
 
        //  If child_mult_ = true, then multiply, else divide
 
 
 
 
 
 
 
    private:
 
        MultOperator() = default;
 
        // Stores the mult/div of a factor.  There is a one-one
        // correspondence between elements of signs_ and operand_.  This
        // is enforced by the AddOperand method, redefined in MultOperator.
 
        // TODO(JBC): If we add method to delete child, must also delete children_mult_ entry.
        std::vector<bool> mult_or_div_;
 
 
    private:
 
        friend class boost::serialization::access;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<NaryOperator>(*this);
            ar & mult_or_div_;
        }
 
        void PrecisionChangeSpecific(unsigned prec) const override
        {
            temp_mp_.precision(prec);
        }
 
        mutable complex_mp temp_mp_;
        mutable complex_dbl temp_d_;
 
        friend SumOperator;
    };
 
 
 
 

    class PowerOperator : public Operator
    {
 
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;

        template<typename... Ts>
        static
        std::shared_ptr<PowerOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<PowerOperator>(Intern(std::shared_ptr<Node>( new PowerOperator(ts...) )));
        }
 
 
    private:
        PowerOperator(const std::shared_ptr<Node> & new_base, const std::shared_ptr<Node> & new_exponent) : base_(new_base), exponent_(new_exponent)
        {
        }
 
    public:
 
 

        void SetBase(std::shared_ptr<Node> new_base)
        {
            base_ = new_base;
        }

        void SetExponent(std::shared_ptr<Node> new_exponent)
        {
            exponent_ = new_exponent;
        }

        std::shared_ptr<Node> GetBase() const
        {
            return base_;
        }

        std::shared_ptr<Node> GetExponent() const
        {
            return exponent_;
        }
 
 
 
 
        void print(std::ostream & target) const override;
 
        unsigned Precedence() const override
        {
            return PrecPower;
        }
 
 

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;

        int Degree(std::shared_ptr<Variable> const& v = nullptr) const override;
 
        int Degree(VariableGroup const& vars) const override;

        std::vector<int> MultiDegreeImpl(VariableGroup const& vars) const override;
 
 
 
        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;
        std::size_t HashImpl() const override;
        bool IsSame(Node const& other) const override;
 
        bool IsHomogeneous(std::shared_ptr<Variable> const& v = nullptr) const override;

        bool IsHomogeneous(VariableGroup const& vars) const override;
 
        virtual ~PowerOperator() = default;

 
 
 
    protected:
 
 
 
    private:
 
        PowerOperator() = default;
 
        std::shared_ptr<Node> base_;
        std::shared_ptr<Node> exponent_;
 
 
 
    private:
 
        friend class boost::serialization::access;
 
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<Operator>(*this);
            ar & base_;
            ar & exponent_;
        }
    };
    // end of the class PowerOperator
 
 
 
 
 
 
 
 
 
 
 
 
 

    class IntegerPowerOperator : public UnaryOperator
    {
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;
        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;
        std::size_t HashImpl() const override;
        bool IsSame(Node const& other) const override;

        void print(std::ostream & target) const override;
 
        unsigned Precedence() const override
        {
            return PrecPower;
        }
 

        void set_exponent(int exp)
        {
            exponent_ = exp;
        }
 

        int exponent() const
        {
            return exponent_;
        }
 

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;

        int Degree(std::shared_ptr<Variable> const& v = nullptr) const override;
 
        int Degree(VariableGroup const& vars) const override;
 
 
        bool IsHomogeneous(std::shared_ptr<Variable> const& v = nullptr) const override
        {
            return operand_->IsHomogeneous(v);
        }
 

        bool IsHomogeneous(VariableGroup const& vars) const override
        {
            return operand_->IsHomogeneous(vars);
        }
 
 
        virtual ~IntegerPowerOperator() = default;
 

        template<typename... Ts>
        static
        std::shared_ptr<IntegerPowerOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<IntegerPowerOperator>(Intern(std::shared_ptr<Node>( new IntegerPowerOperator(ts...) )));
        }
 
    private:
        IntegerPowerOperator(const std::shared_ptr<Node> & N, int p) : UnaryOperator(N), exponent_(p)
        {}
 
 
 
 
    protected:
 
 
 
 
 
 
 
    private:
 
        IntegerPowerOperator() = default;
 
 
        int exponent_; 
 
        friend class boost::serialization::access;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<UnaryOperator>(*this);
            ar & exponent_;
        }
    }; // re: class IntegerPowerOperator
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

    class SqrtOperator : public UnaryOperator
    {
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        
        template<typename... Ts>
        static
        std::shared_ptr<SqrtOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<SqrtOperator>(Intern(std::shared_ptr<Node>( new SqrtOperator(ts...) )));
        }
 
    private:
        SqrtOperator(const std::shared_ptr<Node> & N) : UnaryOperator(N)
        {};
 
    public:
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;
        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;
 
        void print(std::ostream & target) const override;
 

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;
 
 
        virtual ~SqrtOperator() = default;
 
    protected:
 
 
 
 
    private:
 
        SqrtOperator() = default;
 
        friend class boost::serialization::access;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<UnaryOperator>(*this);
        }
    };
 
 

    inline std::shared_ptr<Node> sqrt(const std::shared_ptr<Node> & N)
    {
        return SqrtOperator::Make(N);
    }
 
 
 

    class ExpOperator : public UnaryOperator
    {
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;
        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;

        template<typename... Ts>
        static
        std::shared_ptr<ExpOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<ExpOperator>(Intern(std::shared_ptr<Node>( new ExpOperator(ts...) )));
        }
 
    private:
        ExpOperator(const std::shared_ptr<Node> & N) : UnaryOperator(N)
        {};
 
    public:
 
 
 
 
        void print(std::ostream & target) const override;
 

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;
 
 
        virtual ~ExpOperator() = default;
 
    protected:
 
 
 
    private:
        ExpOperator() = default;
        friend class boost::serialization::access;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<UnaryOperator>(*this);
        }
    };
 

    class LogOperator : public UnaryOperator
    {
    public:
        BERTINI_DEFAULT_VISITABLE()
 
        std::shared_ptr<Node> Simplified() const override;
 
        std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const override;
        std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const override;

        template<typename... Ts>
        static
        std::shared_ptr<LogOperator> Make(Ts&& ...ts){
            return std::static_pointer_cast<LogOperator>(Intern(std::shared_ptr<Node>( new LogOperator(ts...) )));
        }
 
    private:
        LogOperator(const std::shared_ptr<Node> & N) : UnaryOperator(N)
        {};
 
    public:
 
 
 
 
        void print(std::ostream & target) const override;
 

        std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v = nullptr) const override;
 
 
        virtual ~LogOperator() = default;
 
    protected:
 
 
 
    private:
        LogOperator() = default;
        friend class boost::serialization::access;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & boost::serialization::base_object<UnaryOperator>(*this);
        }
    };
 
 
 
 
    // begin the overload of operators

    inline std::shared_ptr<Node> exp(const std::shared_ptr<Node> & N)
    {
        return ExpOperator::Make(N);
    }

    inline std::shared_ptr<Node> log(const std::shared_ptr<Node> & N)
    {
        return LogOperator::Make(N);
    }

    inline std::shared_ptr<Node> pow(const std::shared_ptr<Node> & N, const std::shared_ptr<Node> & p)
    {
        return PowerOperator::Make(N,p);
    }

    inline std::shared_ptr<Node> pow(std::shared_ptr<Node> const& base, int power)
    {
        return IntegerPowerOperator::Make(base,power);
    }

    std::shared_ptr<Node> pow(const std::shared_ptr<Node> & N, double p) = delete;

    std::shared_ptr<Node> pow(const std::shared_ptr<Node> & N, complex_dbl p) = delete;

    inline std::shared_ptr<Node> pow(const std::shared_ptr<Node> & N, real_mp p)
    {
        return PowerOperator::Make(N,Complex::Make(p));
    }

    inline std::shared_ptr<Node> pow(const std::shared_ptr<Node> & N, complex_mp p)
    {
        return PowerOperator::Make(N,Complex::Make(p));
    }

    inline std::shared_ptr<Node> pow(const std::shared_ptr<Node> & N, mpq_rational const& p)
    {
        return PowerOperator::Make(N,Rational::Make(p,0));
    }
 
 
 
 
 

    //
    //     SIMPLIFIED-CONSTRUCTION FACTORIES
    //

    std::shared_ptr<Node> SimplifiedNegate(std::shared_ptr<Node> const& n);

    std::shared_ptr<Node> SimplifiedSum(std::vector<std::pair<std::shared_ptr<Node>, bool>> const& terms);

    std::shared_ptr<Node> SimplifiedMult(std::vector<std::pair<std::shared_ptr<Node>, bool>> const& factors);
 
 

    //
    //     SUM AND DIFFERENCE ARITHMETIC OPERATORS
    //
 
 
 

    //
    //  addition operators
    //
 

    inline std::shared_ptr<Node>& operator+=(std::shared_ptr<Node> & lhs, const std::shared_ptr<Node> & rhs)
    {
        std::shared_ptr<Node> temp = SumOperator::Make(lhs,rhs);
        lhs.swap(temp);
        return lhs;
    }
 
 
 
 

    inline std::shared_ptr<Node> operator+(std::shared_ptr<Node> lhs, const std::shared_ptr<Node> & rhs)
    {
        return SumOperator::Make(lhs,rhs);
    }

    inline std::shared_ptr<Node> operator+(std::shared_ptr<Node> lhs, real_mp const& rhs)
    {
        return SumOperator::Make(lhs,Complex::Make(rhs));
    }

    inline std::shared_ptr<Node> operator+(std::shared_ptr<Node> lhs, complex_mp const& rhs)
    {
        return SumOperator::Make(lhs,Complex::Make(rhs));
    }

    inline std::shared_ptr<Node> operator+(real_mp const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Complex::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator+(complex_mp const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Complex::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator+(std::shared_ptr<Node> lhs, int rhs)
    {
        return SumOperator::Make(lhs,Integer::Make(rhs));
    }

    inline std::shared_ptr<Node> operator+(int lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Integer::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator+(std::shared_ptr<Node> lhs, mpz_int const& rhs)
    {
        return SumOperator::Make(lhs,Integer::Make(rhs));
    }

    inline std::shared_ptr<Node> operator+(mpz_int const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Integer::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator+(std::shared_ptr<Node> lhs, mpq_rational const& rhs)
    {
        return SumOperator::Make(lhs,Rational::Make(rhs,0));
    }

    inline std::shared_ptr<Node> operator+(mpq_rational const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Rational::Make(lhs,0), rhs);
    }
 
 

    //
    //  subtraction operators
    //
 

    inline std::shared_ptr<Node>& operator-=(std::shared_ptr<Node> & lhs, const std::shared_ptr<Node> & rhs)
    {
        std::shared_ptr<Node> temp = SumOperator::Make(lhs,true,rhs,false);
        lhs.swap(temp);
        return lhs;
    }
 

    inline std::shared_ptr<Node> operator-(std::shared_ptr<Node> lhs, const std::shared_ptr<Node> & rhs)
    {
        return SumOperator::Make(lhs,true,rhs,false);
    }

    inline std::shared_ptr<Node> operator-(std::shared_ptr<Node> lhs, real_mp const& rhs)
    {
        return SumOperator::Make(lhs, true, Complex::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator-(real_mp const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Complex::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator-(std::shared_ptr<Node> lhs, complex_mp const& rhs)
    {
        return SumOperator::Make(lhs, true, Complex::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator-(complex_mp const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Complex::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator-(std::shared_ptr<Node> lhs, int rhs)
    {
        return SumOperator::Make(lhs, true, Integer::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator-(int lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Integer::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator-(std::shared_ptr<Node> lhs, mpz_int const& rhs)
    {
        return SumOperator::Make(lhs, true, Integer::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator-(mpz_int const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Integer::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator-(std::shared_ptr<Node> lhs, mpq_rational const& rhs)
    {
        return SumOperator::Make(lhs, true, Rational::Make(rhs,0), false);
    }

    inline std::shared_ptr<Node> operator-(mpq_rational const& lhs,  std::shared_ptr<Node> rhs)
    {
        return SumOperator::Make(Rational::Make(lhs,0), true, rhs, false);
    }
 
 
 
    /*
     multiplication operators
     */
    inline std::shared_ptr<Node> operator*=(std::shared_ptr<MultOperator> & lhs, const std::shared_ptr<Node> & rhs)
    {
        lhs->AddOperand(rhs);
        return lhs;
    }
 

    inline std::shared_ptr<Node> operator*(std::shared_ptr<Node> lhs, real_mp const& rhs)
    {
        return MultOperator::Make(lhs,Complex::Make(rhs));
    }

    inline std::shared_ptr<Node> operator*(std::shared_ptr<Node> lhs, complex_mp const& rhs)
    {
        return MultOperator::Make(lhs,Complex::Make(rhs));
    }

    inline std::shared_ptr<Node> operator*(real_mp const& lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Complex::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator*(complex_mp const& lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Complex::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator*(std::shared_ptr<Node> lhs, int rhs)
    {
        return MultOperator::Make(lhs,Integer::Make(rhs));
    }

    inline std::shared_ptr<Node> operator*(int lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Integer::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator*(std::shared_ptr<Node> lhs, mpz_int const& rhs)
    {
        return MultOperator::Make(lhs,Integer::Make(rhs));
    }

    inline std::shared_ptr<Node> operator*(mpz_int const& lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Integer::Make(lhs), rhs);
    }

    inline std::shared_ptr<Node> operator*(std::shared_ptr<Node> lhs, mpq_rational const& rhs)
    {
        return MultOperator::Make(lhs,Rational::Make(rhs,0));
    }

    inline std::shared_ptr<Node> operator*(mpq_rational const& lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Rational::Make(lhs,0), rhs);
    }
 

    inline std::shared_ptr<Node>& operator*=(std::shared_ptr<Node> & lhs, const std::shared_ptr<Node> & rhs)
    {
        std::shared_ptr<Node> temp = MultOperator::Make(lhs,rhs);
        lhs.swap(temp);
        return lhs;
    }

    inline std::shared_ptr<Node> operator*(std::shared_ptr<Node> lhs, const std::shared_ptr<Node> & rhs)
    {
        return lhs*=rhs;
    }
 
 
 
 
 
 
    /*
     division operators
     */
 

    inline std::shared_ptr<Node>& operator/=(std::shared_ptr<Node> & lhs, const std::shared_ptr<Node> & rhs)
    {
 
        // if (std::dynamic_pointer_cast<IntegerPowerOperator>(lhs) && std::dynamic_pointer_cast<IntegerPowerOperator>(rhs))
        // {
 
        //  auto lhs_as_intpow = std::dynamic_pointer_cast<IntegerPowerOperator>(lhs);
        //  auto rhs_as_intpow = std::dynamic_pointer_cast<IntegerPowerOperator>(rhs);
        //  if (lhs_as_intpow->first_child()==rhs_as_intpow->first_child())
        //  {
        //      std::shared_ptr<Node> temp = pow(lhs_as_intpow->first_child(),lhs_as_intpow->exponent() - rhs_as_intpow->exponent());
        //      lhs.swap(temp);
        //      return lhs;
        //  }
        // }
 
 
        std::shared_ptr<Node> temp = MultOperator::Make(lhs,true,rhs,false);
        lhs.swap(temp);
        return lhs;
    }

    inline std::shared_ptr<Node> operator/=(std::shared_ptr<MultOperator> & lhs, const std::shared_ptr<Node> & rhs)
    {
        lhs->AddOperand(rhs,false);
        return lhs;
    }
 
 

    inline std::shared_ptr<Node> operator/(std::shared_ptr<Node> lhs, const std::shared_ptr<Node> & rhs)
    {
        return lhs/=rhs;
    }

    inline std::shared_ptr<Node> operator/(std::shared_ptr<Node> lhs, real_mp rhs)
    {
        return MultOperator::Make(lhs, true, Complex::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator/(std::shared_ptr<Node> lhs, complex_mp rhs)
    {
        return MultOperator::Make(lhs, true, Complex::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator/(real_mp lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Complex::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator/(complex_mp lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Complex::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator/(std::shared_ptr<Node> lhs, int rhs)
    {
        return MultOperator::Make(lhs, true, Integer::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator/(int lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Integer::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator/(std::shared_ptr<Node> lhs, mpz_int const& rhs)
    {
        return MultOperator::Make(lhs, true, Integer::Make(rhs), false);
    }

    inline std::shared_ptr<Node> operator/(mpz_int const& lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Integer::Make(lhs), true, rhs, false);
    }

    inline std::shared_ptr<Node> operator/(std::shared_ptr<Node> lhs, mpq_rational const& rhs)
    {
        return MultOperator::Make(lhs, true, Rational::Make(rhs,0), false);
    }

    inline std::shared_ptr<Node> operator/(mpq_rational const& lhs,  std::shared_ptr<Node> rhs)
    {
        return MultOperator::Make(Rational::Make(lhs,0), true, rhs, false);
    }
 
 
 
} // re: namespace node
} // re: namespace bertini
 
 
 
 
 
 
#endif