straight_line_program.hpp

Go to the documentation of this file.

 
//This file is part of Bertini 2.
//
//straight_line_program.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.
//
//straight_line_program.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 straight_line_program.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_SLP_HPP
#define BERTINI_SLP_HPP
 
#pragma once
 
#include <assert.h>
#include <vector>
#include <map>
#include <memory>
#include <tuple>
 
#include "bertini2/mpfr_complex.hpp"
#include "bertini2/mpfr_extensions.hpp"
#include "bertini2/eigen_extensions.hpp"
#include "bertini2/function_tree/forward_declares.hpp"
#include "bertini2/detail/visitor.hpp"
 
#include <boost/serialization/utility.hpp>
#include <boost/serialization/split_member.hpp>
 
// code copied from Bertini1's file include/bertini.h
 
 
/*
 
typedef struct
{
    int num_funcs;
    int num_hom_var_gp;
    int num_var_gp;
    int *type; // 0 - hom_var_gp, 1 - var_gp
    int *size; // size of the group of the user listed variables (total size = size + type)
} preproc_data;
 
 
typedef struct
{
    point_d funcVals;
    point_d parVals;
    vec_d parDer;
    mat_d Jv;
    mat_d Jp;
} eval_struct_d;
 
typedef struct
{
    point_mp funcVals;
    point_mp parVals;
    vec_mp parDer;
    mat_mp Jv;
    mat_mp Jp;
} eval_struct_mp;
 
 
The straight-line program structure.  This is the way that polynomials are stored internally.
typedef struct {
    int *prog;     //  The program instructions. (a big integer array)
    int  size;     //  size of the instruction program.
    int  memSize;  // Amount of memory it needs in workspace (for temp and final results).
    num_t *nums;   // The array of real numbers.
    int precision; // The precision at which evaluation should occur
 
    // INFO NEEDED FOR M-HOM:
    int num_var_gps;  // The total number of variable groups (i.e., m from m-hom).
    int *var_gp_sizes;  // The size of each of the groups.
    int index_of_first_number_for_proj_trans;  // The address of the first number used in the projective transformation polynomials.
 
    // STOP LOCATIONS:
    int  numInstAtEndUpdate; // instruction number at end of update. i.e. i = 0; while (i < numInstAtEndUpdate) ..
    int  numInstAtEndParams; // instruction number at end of params. i.e. i = numInstAtEndUpdate; while (i < numInstAtEndParams) ..
    int  numInstAtEndFnEval; // instruction number at end of function eval. i.e. i = numInstAtEndParams; while (i < numInstAtEndFnEval) ..
    int  numInstAtEndPDeriv; // instruction number at end of param diff. i.e. i = numInstAtEndFnEval; while (i < numInstAtEndPDeriv) ..
    int  numInstAtEndJvEval; // instruction number at end of Jv eval. i.e. i = numInstAtEndPDeriv; while (i < numInstAtEndJvEval) ..
                                                     // for Jp eval: i = numInstAtEndJvEval; while (i < size) ..
 
    // INPUT AMOUNTS:
    int  numVars;  //  Number of variables in the function being computed.
    int  numPathVars;  //  Number of path variables.  Ought to be 1 usually.
    int  numNums;  //  Number of real numbers used in evaluation.
    int  numConsts;  //  Number of constants.
 
    // OUTPUT AMOUNTS:
    int  numPars;  //  Number of parameters
    int  numFuncs; //  Number of coordinate functions in the homotopy.
    int  numSubfuncs;  //  Number of subfunctions.
 
    // INPUT LOCATIONS:
    int  inpVars;  //  Where the input variable values are stored.
    int  inpPathVars;  //  Where the values of the path variables are stored.
    int  IAddr;  //  Where the constant I is stored.
    int  numAddr;  //  Where the first num_t is stored.
    int  constAddr;  //  Where the first constant is stored.
 
    // OUTPUT LOCATIONS:
    int  evalPars;  //  Where U(t), for given t, is stored.
    int  evalDPars;  //  Where the derivatives of the parameters are stored.
    int  evalFuncs;  //  Where H(x,t) is stored.
    int  evalJVars;  //  Where the Jacobian w.r.t. vars is stored.
    int  evalJPars;  //  Where the Jacobian w.r.t. pars is stored.
    int  evalSubs;  //  Where the subfunctions are stored
    int  evalJSubsV;  //  Where the derivatives of the subfunctions w.r.t. vars are stored.
    int  evalJSubsP;  //  Where the derivatives of the subfunctions w.r.t. pars are stored.
} prog_t;
*/
 
 
 
namespace bertini {
 
    class SLPCompiler;
    class System; // a forward declaration, solving the circular inclusion problem
    class StraightLineProgram;
 

    enum class NumType : uint8_t { Real = 0, Complex = 1 };  // Integer added in a later stage
 

    enum Operation { // we'll start with the binary ones
        Add=      1 << 0,
        Subtract= 1 << 1,
        Multiply= 1 << 2,
        Divide=   1 << 3,
        Power=    1 << 4,
        Exp=      1 << 5,
        Log=      1 << 6,
        Negate=   1 << 7,
        Sqrt=     1 << 8,
        Sin=      1 << 9,
        Cos=      1 << 10,
        Tan=      1 << 11,
        Asin=     1 << 12,
        Acos=     1 << 13,
        Atan=     1 << 14,
        Assign=   1 << 15,
        IntPower= 1 << 16,
    };
 
    const int BinaryOperations = Add|Subtract | Multiply|Divide | Power | IntPower;  
    const int TrigOperations   = Sin|Cos|Tan | Asin|Acos|Atan;  
    const int UnaryOperations  = Exp|Log | Negate | Assign | TrigOperations | Sqrt;  

    constexpr bool IsUnary(Operation op)
    {
        return op & UnaryOperations;
    }

    constexpr bool IsBinary(Operation op)
    {
        return op & BinaryOperations;
    }

    std::string OpcodeToString(Operation op);

    bool SLPValueNumbering();
    void SetSLPValueNumbering(bool on);
 
    // Compile-time bank selectors (ADR-0034).  After NumType inference, each instruction's opcode word
    // gets these high bits set to record which bank (real or complex) each operand and the result live
    // in, so the hot eval loop reads the banks inline from the instruction it has already loaded instead
    // of looking up slot_numtype_[slot] per operand.  The base Operation occupies bits 0..16, so these
    // sit well clear of it; masking with kOpcodeMask recovers the base op for the switch and for IsUnary.
    constexpr size_t kOpcodeMask = (static_cast<size_t>(1) << 17) - 1;  
    constexpr size_t kArg0Real   =  static_cast<size_t>(1) << 20;  
    constexpr size_t kArg1Real   =  static_cast<size_t>(1) << 21;  
    constexpr size_t kOutReal    =  static_cast<size_t>(1) << 22;  
 

    struct SLPOutputLocations{
        size_t Functions{0};  
        size_t Jacobian{0};   
        size_t TimeDeriv{0};  
 
        friend class boost::serialization::access;

        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & Functions;
            ar & Jacobian;
            ar & TimeDeriv;
        }
    };

    struct SLPInputLocations{
        size_t Variables{0};  
        size_t Time{0};       
 
        friend class boost::serialization::access;

        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & Variables;
            ar & Time;
        }
    };

    struct SLPNumberOf{
        size_t Functions{0};  
        size_t Variables{0};  
        size_t Jacobian{0};   
        size_t TimeDeriv{0};  
 
        friend class boost::serialization::access;

        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & Functions;
            ar & Variables;
            ar & Jacobian;
            ar & TimeDeriv;
        }
    };
 
 

    struct ConstantRecipe{
        enum class Kind : int { Integer, Rational, Complex, Pi, E };
 
        Kind kind = Kind::Integer;          
        mpz_int      int_value;             
        mpq_rational rat_real;              
        mpq_rational rat_imag;              
        complex_mp float_value;             
        size_t slot = 0;                    

        template<typename NumT> NumT Produce() const;

        template<typename RealT> RealT ProduceReal() const;

        bool IsReal() const {
            switch (kind) {
                case Kind::Integer: case Kind::Pi: case Kind::E: return true;
                case Kind::Rational: return rat_imag == 0;
                case Kind::Complex:  return float_value.imag() == 0;
            }
            return false;
        }
 
        friend class boost::serialization::access;
        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            int k = static_cast<int>(kind);
            ar & k;
            kind = static_cast<Kind>(k);
            ar & int_value;
            ar & rat_real;
            ar & rat_imag;
            ar & float_value;
            ar & slot;
        }
    };
 
 

    class SLPMemory{
    public:
        template<typename NumT>
        std::vector<NumT>& Get() { return std::get<std::vector<NumT>>(registers_); }

        template<typename NumT>
        std::vector<NumT> const& Get() const { return std::get<std::vector<NumT>>(registers_); }

        mutable std::tuple< std::vector<real_dbl>, std::vector<complex_dbl>,
                            std::vector<real_mp>,  std::vector<complex_mp> > registers_;
 
        mutable unsigned precision_ = 16; 
        mutable bool is_evaluated_ = false;  
 
        // Whether the frozen prologue's results in memory are valid.  Tracked per number type: the
        // double constants never change once computed; the mpfr constants are valid only while the
        // working precision is unchanged.  Transient (recomputed on first eval; not serialized).
        mutable bool frozen_valid_dbl_ = false;  
        mutable unsigned frozen_valid_mp_precision_ = 0;  
 
        friend class boost::serialization::access;

        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & std::get<std::vector<real_dbl>>(registers_);
            ar & std::get<std::vector<complex_dbl>>(registers_);
            ar & std::get<std::vector<real_mp>>(registers_);
            ar & std::get<std::vector<complex_mp>>(registers_);
            ar & precision_;
            ar & is_evaluated_;
            // frozen_valid_* are transient (recomputed on first eval); not serialized.
        }
    };
 
 

    class SLPProgram{
        friend SLPCompiler;
        friend class StraightLineProgram;
        friend std::ostream& operator <<(std::ostream& out, const StraightLineProgram & s);
 
    private:
        using Nd = std::shared_ptr<const node::Node>;
 
    public:
        using IntT = int;  
 
        SLPProgram() = default;

        static bool tiers_enabled_;

        bool HavePathVariable() const { return has_path_variable_; }
        inline unsigned NumFunctions() const{ return static_cast<unsigned>(number_of_.Functions);}
        inline unsigned NumVariables() const{ return static_cast<unsigned>(number_of_.Variables);}
        inline size_t NumSlots() const { return num_slots_; }
        inline size_t FirstLiveInstructionOffset() const { return first_live_instruction_; }

        std::size_t ContentHash() const;

        bool SameContent(SLPProgram const& other) const;

        template<typename NumT>
        void Eval(SLPMemory& memory) const;  // this definition is in cpp, along with the lines that instantiate the needed versions.
 
    private:
        void AddInstruction(Operation binary_op, size_t in_loc1, size_t in_loc2, size_t out_loc);

        void AddInstruction(Operation unary_op, size_t in_loc, size_t out_loc);

        void AddConstant(ConstantRecipe recipe);
 
        // Reorder `instructions_` into [frozen | live] and set `first_live_instruction_`.  Called once
        // at the end of compilation, after `num_slots_` is set.
        void PartitionInstructions();
 
        // Fill slot_numtype_ by a forward pass over the (dependency-ordered) tape (ADR-0034): seed
        // constant slots from ConstantRecipe::IsReal() and input slots as Complex, then propagate the
        // NumType join through each instruction.  Called at the end of compilation.
        void ComputeSlotNumTypes();
 
        // Pack each instruction's operand/result banks (from slot_numtype_) into its opcode word's high
        // bits (kArg0Real/kArg1Real/kOutReal), so eval dispatches banks without per-slot lookups.  Runs
        // after ComputeSlotNumTypes and PartitionInstructions (it only sets bits; order vs. partition
        // doesn't matter as it rewrites instructions in place).
        void SpecializeInstructions();
 
 
        bool has_path_variable_ = false; 
 
        SLPNumberOf number_of_;  
        SLPOutputLocations output_locations_; 
        SLPInputLocations input_locations_; 
 
        std::vector<IntT> integers_;  
 
        std::vector<size_t> instructions_; 
        std::vector<ConstantRecipe> constant_recipes_; 
 
        // Freeze-set tape partition (ADR-0027).  After compilation the instructions are stably
        // reordered so every "frozen" instruction (one whose result depends only on frozen input
        // slots --- the literal numbers, Pi/E; i.e. the freeze set is currently the constants)
        // precedes every "live" instruction.  `first_live_instruction_` is the word offset where the
        // live segment begins.  The frozen prologue depends only on precision, so a point-only change
        // re-runs from `first_live_instruction_` and reuses the frozen slots already in memory; the
        // whole tape runs only when the frozen values are not yet valid for the working precision.
        size_t first_live_instruction_ = 0;  
 
        size_t num_slots_ = 0; 
 
        // The NumType of each slot (ADR-0034), indexed by global slot number; sized to num_slots_.
        // Selects which register bank a slot lives in.  Default Complex (filled by the compiler);
        // an all-Complex table reproduces the pre-tier behavior exactly.
        std::vector<NumType> slot_numtype_;  
 
 
        friend class boost::serialization::access;

        template <typename Archive>
        void serialize(Archive& ar, const unsigned /*version*/) {
            ar & has_path_variable_;
            ar & number_of_;
            ar & output_locations_;
            ar & input_locations_;
            ar & integers_;
            ar & instructions_;
            ar & constant_recipes_;
            ar & first_live_instruction_;
            ar & num_slots_;
            ar & slot_numtype_;
        }
    };
 
 

    std::shared_ptr<const SLPProgram> InternProgram(std::shared_ptr<const SLPProgram> const& candidate);
 

    class StraightLineProgram{
        friend SLPCompiler;
        friend std::ostream& operator <<(std::ostream& out, const StraightLineProgram & s);
 
    private:
        using Nd = std::shared_ptr<const node::Node>;
 
    public:

        StraightLineProgram(System const & sys);
 
        StraightLineProgram() : program_(std::make_shared<const SLPProgram>()) {}

        template<typename Derived>
        void Eval(Eigen::MatrixBase<Derived> const& variable_values) const
        {
            using NumT = typename Derived::Scalar;
            SetVariableValues(variable_values);
            program_->Eval<NumT>(memory_);
        }

        template<typename Derived, typename ComplexT>
        void Eval(Eigen::MatrixBase<Derived> const& variable_values, ComplexT const& time) const
        {
            using NumT = typename Derived::Scalar;
            static_assert(std::is_same<NumT, ComplexT>::value, "scalar types must be the same");
 
            // 1. copy variable values into memory locations they're supposed to go in
            SetVariableValues(variable_values);
            SetPathVariable(time);
            program_->Eval<NumT>(memory_);
        }
 
 
 
        // a placeholder function that needs to be written.  now just calls eval, since the eval functionality is both functions and jacobian wrapped together -- we don't keep arrays of their locations separately yet, so that would be the starting point.
        template <typename T>
        void EvalFunctions() const{
            program_->Eval<T>(memory_);
        }
 
 
 
        // a placeholder function that needs to be written.  now just calls eval, since the eval functionality is both functions and jacobian wrapped together -- we don't keep arrays of their locations separately yet, so that would be the starting point.
        template <typename T>
        void EvalJacobian() const{
            program_->Eval<T>(memory_);
        }
 
 
        // a placeholder function that needs to be written.  now just calls eval, since the eval functionality is both functions and jacobian wrapped together -- we don't keep arrays of their locations separately yet, so that would be the starting point.
        template <typename T>
        void EvalTimeDeriv() const{
            program_->Eval<T>(memory_);
        }
 

        std::shared_ptr<const SLPProgram> Program() const { return program_; }

        size_t NumRealSlots() const {
            size_t n = 0;
            for (auto t : program_->slot_numtype_) if (t == NumType::Real) ++n;
            return n;
        }
 
        // Read a slot's value as NumT (complex), pulling from the real or complex bank per its NumType
        // (ADR-0034).  Used to copy outputs out, since a function/derivative slot could be Real-typed.
        template<typename NumT>
        NumT ReadSlotAsComplex(size_t slot) const {
            using RealT = typename NumTraits<NumT>::Real;
            if (program_->slot_numtype_[slot] == NumType::Real)
                return NumT(memory_.template Get<RealT>()[slot]);
            return memory_.template Get<NumT>()[slot];
        }

        template<typename NumT>
        void GetFuncValsInPlace(Eigen::Ref<Vec<NumT>> result) const{
            if (!memory_.is_evaluated_)
                program_->Eval<NumT>(memory_);
 
            // copy content (an output slot may be Real-typed; read from the bank its NumType selects)
            for (size_t ii = 0; ii < program_->number_of_.Functions; ++ii) {
                result(static_cast<Eigen::Index>(ii)) = ReadSlotAsComplex<NumT>(ii + program_->output_locations_.Functions);
            }
        }

 
        template<typename NumT>
        void GetJacobianInPlace(Eigen::Ref<Mat<NumT>> result) const{
            if (!memory_.is_evaluated_)
                program_->Eval<NumT>(memory_);
 
            // copy content (a derivative slot may be Real-typed; read from the bank its NumType selects)
            for (size_t jj =0; jj < program_->number_of_.Variables; ++jj) {
                for (size_t ii = 0; ii < program_->number_of_.Functions; ++ii) {
                    result(static_cast<Eigen::Index>(ii), static_cast<Eigen::Index>(jj)) = ReadSlotAsComplex<NumT>(ii+jj*program_->number_of_.Functions + program_->output_locations_.Jacobian);
                }
            }
        }

 
        template<typename NumT>
        void GetTimeDerivInPlace(Eigen::Ref<Vec<NumT>> result) const{
            if (!memory_.is_evaluated_)
                program_->Eval<NumT>(memory_);
 
            // copy content (a time-derivative slot may be Real-typed; read from the right bank)
            for (size_t ii = 0; ii < program_->number_of_.Functions; ++ii) {
                result(static_cast<Eigen::Index>(ii)) = ReadSlotAsComplex<NumT>(ii + program_->output_locations_.TimeDeriv);
            }
        }

        template<typename NumT>
        Vec<NumT> GetFuncVals() const{
            Vec<NumT> return_me(this->NumFunctions());
            GetFuncValsInPlace<NumT>(return_me);
            return return_me;
        }

        template<typename NumT>
        Mat<NumT> GetJacobian() const{
            Mat<NumT> return_me(this->NumFunctions(), this->NumVariables());
            GetJacobianInPlace<NumT>(return_me);
            return return_me;
        }

        template<typename NumT>
        Vec<NumT> GetTimeDeriv() const{
            Vec<NumT> return_me(this->NumFunctions());
            GetTimeDerivInPlace<NumT>(return_me);
            return return_me;
        }
 

        inline unsigned NumFunctions() const{ return program_->NumFunctions();}

        inline unsigned NumVariables() const{ return program_->NumVariables();}

        inline size_t NumMemorySlots() const{ return program_->NumSlots(); }

        inline size_t FirstLiveInstructionOffset() const { return program_->FirstLiveInstructionOffset(); }
 

        inline
        unsigned precision() const
        {
            return memory_.precision_;
        }

        void precision(unsigned new_precision) const;

        template<typename Derived>
        void SyncPrecision(Eigen::MatrixBase<Derived> const& variable_values) const
        {
            using NumT = typename Derived::Scalar;
            if constexpr (!std::is_same<NumT,complex_dbl>::value)
            {
                if (variable_values.size() > 0 && Precision(variable_values)!=memory_.precision_)
                    this->precision(Precision(variable_values));
            }
        }

        bool HavePathVariable() const {
            return program_->has_path_variable_;
        }

        friend std::ostream& operator <<(std::ostream& out, const StraightLineProgram & s);
 
 
 

        template<typename Derived>
        void SetVariableValues(Eigen::MatrixBase<Derived> const& variable_values) const{
            using NumT = typename Derived::Scalar;
 
            // The Memory's precision is an ARTIFACT OF THE CURRENT EVALUATION, never an
            // invariant to defend.  The compiled Program is a precision-independent tape of
            // operations; only the Memory holding values carries digits.  So evaluating at
            // whatever precision the caller brings is always meaningful, and the right
            // response to a mismatch is to RE-TAG THE MEMORY, not to refuse.
            //
            // Refusing was a genuine trap, not merely unergonomic.  A Memory takes its
            // precision from the ambient DefaultPrecision() when the program is lazily
            // compiled, while the owning System keeps whatever it was told, so the two
            // diverge the moment anything moves the ambient default -- which an AMP tracker
            // or endgame does as a matter of course.  The System was then WEDGED with no way
            // out: evaluating at its own reported precision raised here, and
            // System::precision(n) could not repair it, because both setters short-circuit
            // when the value they are handed already equals the one they hold.  See #377.
            //
            // An empty variable vector (a constant program with no variables) has no
            // precision to read.  Re-tagging refills the constants from their exact recipes
            // at the new precision, so accuracy is rebuilt rather than padded with zeros.
            SyncPrecision(variable_values);
 
            auto& memory = memory_.Get<NumT>(); // unpack for local reference
 
            for (size_t ii = 0; ii < program_->number_of_.Variables; ++ii) {
                //assign  to memory
                memory[ii + program_->input_locations_.Variables] = variable_values(static_cast<Eigen::Index>(ii));
            }
            memory_.is_evaluated_ = false;
        }

        template<typename ComplexT>
        void SetPathVariable(ComplexT const& time) const{
 
            // Same doctrine as SetVariableValues, but this one only ever raises: the
            // variables have already been written into memory by the time the path variable
            // arrives, so re-tagging DOWNWARD here would truncate them.  Memory therefore
            // ends an evaluation at the max of its arguments' precisions.
            if constexpr (!std::is_same<ComplexT,complex_dbl>::value)
            {
                if (Precision(time) > memory_.precision_)
                    this->precision(Precision(time));
            }
 
            if (!this->HavePathVariable())
                throw std::runtime_error("calling Eval with path variable, but this StraightLineProgram doesn't have one.");
            // then actually copy the path variable into where it goes in memory
 
            auto& memory = memory_.Get<ComplexT>(); // unpack for local reference
 
            memory[program_->input_locations_.Time] = time;
            // assigning an mp value adopts the SOURCE's precision, so a lower-precision time
            // would otherwise leave one slot out of step with the rest of memory
            if constexpr (!std::is_same<ComplexT,complex_dbl>::value)
                Precision(memory[program_->input_locations_.Time], memory_.precision_);
            memory_.is_evaluated_ = false;
        }
 
 
 
 
 
 
        using IntT = int;  
 
        private:
 
        // Size the register file to the program's slot count and copy the constant values in.  Called
        // by the compiler once the program is built and memory_.precision_ is set.
        void SetupMemory();

        template<typename NumT>
        void CopyNumbersIntoMemory() const;
 
 
        std::shared_ptr<const SLPProgram> program_; 
        mutable SLPMemory memory_;                  
 
 
 
        friend class boost::serialization::access;

 
        // The program is serialized by value through the (owning, this-stage) shared_ptr, sidestepping
        // boost's shared_ptr<const T> handling.  Clone (system.cpp) recompiles the SLP after a round
        // trip anyway; node_serialization round-trips it faithfully.
        template <typename Archive>
        void save(Archive& ar, const unsigned /*version*/) const {
            SLPProgram const& prog = *program_;
            ar & prog;
            ar & memory_;
        }
 
        template <typename Archive>
        void load(Archive& ar, const unsigned /*version*/) {
            auto prog = std::make_shared<SLPProgram>();
            ar & *prog;
            // Re-intern on load (ADR-0042): a deserialized program unifies with a content-equal
            // live one instead of forking the intern universe.
            program_ = InternProgram(std::shared_ptr<const SLPProgram>(std::move(prog)));
            ar & memory_;
        }
 
        BOOST_SERIALIZATION_SPLIT_MEMBER()
 
    };
 

    class SLPCompiler : public VisitorBase,
 
            // IF YOU ADD A THING HERE, YOU MUST ADD IT ABOVE AND IN THE CPP SOURCE
 
 
            // symbols and roots
            public Visitor<node::Variable>,
            public Visitor<node::Integer>,
            public Visitor<node::Complex>,
            public Visitor<node::Rational>,
            public Visitor<node::NamedExpression>,
            public Visitor<node::Differential>,
 
            // arithmetic
            public Visitor<node::SumOperator>,
            public Visitor<node::MultOperator>,
            public Visitor<node::IntegerPowerOperator>,
            public Visitor<node::PowerOperator>,
            public Visitor<node::ExpOperator>,
            public Visitor<node::LogOperator>,
            public Visitor<node::NegateOperator>,
            public Visitor<node::SqrtOperator>,
 
            // the trig operators
            public Visitor<node::SinOperator>,
            public Visitor<node::ArcSinOperator>,
            public Visitor<node::CosOperator>,
            public Visitor<node::ArcCosOperator>,
            public Visitor<node::TanOperator>,
            public Visitor<node::ArcTanOperator>,
 
            public Visitor<node::special_number::Pi>,
            public Visitor<node::special_number::E>
 
            // also missing -- linears and difflinears.
 
            // these abstract base types left out,
 
            // but commented here to explain why
            //    public Visitor<node::Operator>,// abstract
            //    public Visitor<node::UnaryOperator>,// abstract
            //    public Visitor<node::NaryOperator>,// abstract
            //    public Visitor<node::TrigOperator>,// abstract
    {
    private:
        using Nd = std::shared_ptr<const node::Node>;
        using SLP = StraightLineProgram;
 
        public:
 
            // Compile from any source exposing the variable-ordering / functions / derivatives /
            // path-variable accessors -- both System and blocks::PolynomialBlock qualify.
            // Definition + explicit instantiations live in straight_line_program.cpp.
            template <typename SourceT>
            SLP Compile(SourceT const& source);
 
 
            // IF YOU ADD A THING HERE, YOU MUST ADD IT ABOVE AND IN THE CPP SOURCE

            // symbols and roots
            virtual void Visit(node::Variable const& n);
            virtual void Visit(node::Integer const& n);
            virtual void Visit(node::Complex const& n);
            virtual void Visit(node::Rational const& n);
            virtual void Visit(node::NamedExpression const& n);
            virtual void Visit(node::Differential const& n);
 
            // arithmetic
            virtual void Visit(node::SumOperator const& n);
            virtual void Visit(node::MultOperator const& n);
            virtual void Visit(node::IntegerPowerOperator const& n);
            virtual void Visit(node::PowerOperator const& n);
            virtual void Visit(node::ExpOperator const& n);
            virtual void Visit(node::LogOperator const& n);
            virtual void Visit(node::NegateOperator const& n);
            virtual void Visit(node::SqrtOperator const& n);
 
 
            // the trig operators
            virtual void Visit(node::SinOperator const& n);
            virtual void Visit(node::ArcSinOperator const& n);
            virtual void Visit(node::CosOperator const& n);
            virtual void Visit(node::ArcCosOperator const& n);
            virtual void Visit(node::TanOperator const& n);
            virtual void Visit(node::ArcTanOperator const& n);
 
            virtual void Visit(node::special_number::Pi const& n);
            virtual void Visit(node::special_number::E const& n);
            // missing -- linear and difflinear
        private:
 

            void RegisterConstant(Nd const& nd, ConstantRecipe recipe);

            size_t EmitBinary(Operation op, size_t a, size_t b);
            size_t EmitUnary(Operation op, size_t a);

            void Clear();
 
            size_t next_available_complex_ = 0; 
            size_t next_available_int_ = 0; 
 
            using IntT = int;  
 
            std::map<Nd, size_t> locations_encountered_nodes_; 
            std::map<IntT, size_t> locations_integers_;  
 
            // Value-numbering tables (instruction-level CSE): map an emitted computation to the slot
            // holding its result, so an identical later computation reuses it.  Keyed by (op, operand
            // slots); commutative ops canonicalize operand order before keying.  Reset per Compile.
            std::map<std::tuple<Operation,size_t,size_t>, size_t> vn_binary_;
            std::map<std::pair<Operation,size_t>, size_t>         vn_unary_;
 
            SLPProgram program_under_construction_; 
    };
 
 
 
} // namespace bertini
 
 
 
 
#endif // for the ifndef include guards