node.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//node.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.
//
//node.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 node.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.

 
#ifndef BERTINI_NODE_BASE_HPP
#define BERTINI_NODE_BASE_HPP
 
 
 
 
#include <iostream>
#include <string>
#include <map>
#include <tuple>
#include <optional>
#include <typeinfo>
 
#include <boost/type_index.hpp>
 
#include "bertini2/num_traits.hpp"
#include "bertini2/detail/visitable.hpp"
#include "bertini2/function_tree/forward_declares.hpp"
#include "bertini2/function_tree/print_dialect.hpp"
 
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/tracking.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/nvp.hpp>
 
 
 
 
 
namespace bertini {
 
    namespace node{
        class Variable;
    }

using VariableGroup = std::vector< std::shared_ptr<node::Variable> >;

using SubstitutionMap = std::map< std::string, std::shared_ptr<node::Node> >;
 
 

enum class VariableGroupType
{
    Homogeneous,  
    Affine,       
    Ungrouped     
};
 
 
namespace node{

enum PrintPrecedence : unsigned {
    PrecSum = 10,
    PrecNegate = 15,
    PrecMult = 20,
    PrecPower = 30,
    PrecAtom = 100
};

class Node : public VisitableBase<>, public std::enable_shared_from_this<Node>
{
public:
 
    virtual ~Node() = default;

 
 

    virtual std::shared_ptr<Node> Simplified() const;

    virtual std::shared_ptr<Node> Subs(SubstitutionMap const& substitutions) const;

    virtual void print(std::ostream& target) const = 0;

    virtual unsigned Precedence() const
    {
        return PrecAtom;
    }

    virtual bool IsLiteralZero() const
    {
        return false;
    }

    virtual bool IsLiteralOne() const
    {
        return false;
    }

    std::size_t Hash() const;

    std::shared_ptr<const void> EvalProgram() const { return eval_program_; }
    void SetEvalProgram(std::shared_ptr<const void> p) const { eval_program_ = p; }

    virtual bool IsSame(Node const& other) const;
 

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

    std::shared_ptr<Node> Differentiate(std::shared_ptr<Variable> const& v, unsigned count) const;

    std::shared_ptr<Node> Differentiate(VariableGroup const& vars) const;

    virtual int Degree(std::shared_ptr<Variable> const& v = nullptr) const = 0;
 
 

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

    virtual std::vector<int> MultiDegreeImpl(VariableGroup const& vars) const = 0;

    virtual int Degree(VariableGroup const& vars) const = 0;

    virtual std::shared_ptr<Node> Homogenized(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) const;

    virtual bool IsHomogeneous(std::shared_ptr<Variable> const& v = nullptr) const = 0;

    virtual bool IsHomogeneous(VariableGroup const& vars) const = 0;


    bool IsPolynomial(std::shared_ptr<Variable> const&v = nullptr) const;
 

    bool IsPolynomial(VariableGroup const&v) const;
 
 
 
 
 
 
protected:
    mutable std::optional<std::size_t> structural_hash_;

    mutable std::shared_ptr<const void> eval_program_;

    virtual std::size_t HashImpl() const;

    static void HashCombine(std::size_t& seed, std::size_t value)
    {
        seed ^= value + 0x9e3779b97f4a7c15ULL + (seed << 6) + (seed >> 2);
    }
 
 
 
    Node();
 
private:
    friend std::ostream& operator<<(std::ostream & out, const Node& N);
 
    friend class boost::serialization::access;
 
    template <typename Archive>
    void serialize(Archive& ar, const unsigned /*version*/) {
        register_derived_node_types(ar);
    }
 
}; // re: class node

    inline std::ostream& operator<<(std::ostream & out, const Node& N)
    {
        N.print(out);
        return out;
    }

    inline std::ostream& operator<<(std::ostream & out, const std::shared_ptr<Node>& N)
    {
        N->print(out);
        return out;
    }

    inline std::string PrintIn(Node const& N, PrintDialect dialect)
    {
        std::ostringstream out;
        SetDialect(out, dialect);
        N.print(out);
        return out.str();
    }

    inline std::string PrintClassic(Node const& N) { return PrintIn(N, PrintDialect::Classic); }

    inline std::string PrintPython(Node const& N, bool exact)
    {
        return PrintIn(N, exact ? PrintDialect::PythonExact : PrintDialect::PythonReadable);
    }
 

    std::shared_ptr<Node> Intern(std::shared_ptr<Node> const& candidate);
 
 
    } // re: namespace node
} // re: namespace bertini
 
 
 
#endif
/* defined(BERTINI_NODE_BASE_HPP) */