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) 2015 - 2021 by 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.
 
// individual authors of this file include:
//  James Collins
//  West Texas A&M University
//  Spring, Summer 2015
//
//
// silviana amethyst
// University of Wisconsin - Eau Claire
//
//  Created by Collins, James B. on 4/30/15.
 

 
#ifndef BERTINI_NODE_BASE_HPP
#define BERTINI_NODE_BASE_HPP
 
 
 
 
#include <iostream>
#include <string>
#include <tuple>
 
#include <boost/type_index.hpp>
 
#include "bertini2/num_traits.hpp"
#include "bertini2/detail/visitable.hpp"
#include "bertini2/function_tree/forward_declares.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> >;
 
 
 
enum class VariableGroupType
{
    Homogeneous,
    Affine,
    Ungrouped
};
 
 
namespace node{
 
namespace detail{
    template<typename T>
    struct FreshEvalSelector
    {};
 
    template<>
    struct FreshEvalSelector<dbl>
    {
        
        template<typename N>
        static dbl Run(N const& n, std::shared_ptr<Variable> const& diff_variable)
        {
            return n.FreshEval_d(diff_variable);
        }
        
        
        template<typename N>
        static void RunInPlace(dbl& evaluation_value, N const& n, std::shared_ptr<Variable> const& diff_variable)
        {
            n.FreshEval_d(evaluation_value, diff_variable);
        }
 
    };
 
    template<>
    struct FreshEvalSelector<mpfr_complex>
    {
        template<typename N>
        static mpfr_complex Run(N const& n, std::shared_ptr<Variable> const& diff_variable)
        {
            return n.FreshEval_mp(diff_variable);
        }
        
        
        template<typename N>
        static void RunInPlace(mpfr_complex& evaluation_value, N const& n, std::shared_ptr<Variable> const& diff_variable)
        {
            n.FreshEval_mp(evaluation_value, diff_variable);
        }
 
    };
}
class Node : public virtual VisitableBase<>, public std::enable_shared_from_this<Node>
{
    friend detail::FreshEvalSelector<dbl>;
    friend detail::FreshEvalSelector<mpfr_complex>;
public:
    
    virtual ~Node() = default;
    
  
 

    virtual void Reset() const = 0;
    
    
    
 
    public:
    template<typename T>
    T Eval(std::shared_ptr<Variable> const& diff_variable = nullptr) const 
    {
        T result;
        EvalInPlace(result, diff_variable);
        return result;
    }
    

    template<typename T>
    void EvalInPlace(T& eval_value, std::shared_ptr<Variable> const& diff_variable = nullptr) const;
 
    
 

    virtual unsigned EliminateOnes() = 0;
    
    virtual unsigned EliminateZeros() = 0;
 

    virtual unsigned ReduceDepth();

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

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

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

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

    virtual void Homogenize(VariableGroup const& vars, std::shared_ptr<Variable> const& homvar) = 0;

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

    virtual bool IsHomogeneous(VariableGroup const& vars) const = 0;
    
    
    virtual void precision(unsigned int prec) const = 0;
 
    unsigned precision() const;


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

    bool IsPolynomial(VariableGroup const&v) const;
 
 
    
    
    
 
protected:
    //Stores the current value of the node in all required types
    //We must hard code in all types that we want here.
    //TODO: Initialize this to some default value, second = false
    mutable std::tuple< std::pair<dbl,bool>, std::pair<mpfr_complex,bool> > current_value_;
    
    
    
    
    virtual dbl FreshEval_d(std::shared_ptr<Variable> const&) const = 0;

    virtual void FreshEval_d(dbl& evaluation_value, std::shared_ptr<Variable> const&) const = 0;
 
    
    virtual mpfr_complex FreshEval_mp(std::shared_ptr<Variable> const&) const = 0;
    
    virtual void FreshEval_mp(mpfr_complex& evaluation_value, std::shared_ptr<Variable> const&) const = 0;
 
    
    
    
    
    
    void ResetStoredValues() const;
 
    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;
    }
 
 
 
    // inherit from this to get a nice method of producing shared pointers to specific type, solving the diamond problem
    //
    // T is a derived type
    //
    // I adapted from:
    // https://stackoverflow.com/questions/16082785/use-of-enable-shared-from-this-with-multiple-inheritance
    //
    template<typename T>
    struct EnableSharedFromThisVirtual: public virtual Node
    {
 
    public:
 
        std::shared_ptr<T> shared_from_this() {
           return std::dynamic_pointer_cast<T>(Node::shared_from_this());
        }
 
        std::shared_ptr<const T> shared_from_this() const{
           return std::dynamic_pointer_cast<const T>(Node::shared_from_this());
        }
 
 
 
        template <class ThisT>
        std::shared_ptr<ThisT> downcast_shared_from_this(){
            return std::dynamic_pointer_cast<ThisT>(Node::shared_from_this());
        }
 
        template <class ThisT>
        std::shared_ptr<const ThisT> downcast_shared_from_this() const{
            return std::dynamic_pointer_cast<const ThisT>(Node::shared_from_this());
        }
 
    };
 
 
 
    } // re: namespace node
} // re: namespace bertini
 
 
 
#endif 
/* defined(BERTINI_NODE_BASE_HPP) */