witness_set.hpp

Go to the documentation of this file.

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

 
 
#pragma once
 
#include <deque>
#include <boost/serialization/deque.hpp>
#include <boost/serialization/split_member.hpp>
#include "bertini2/eigen_extensions.hpp"
#include "bertini2/nag_datatypes/common/policies.hpp"
#include "bertini2/system/slice.hpp"
#include "bertini2/system/system.hpp"
 
 
namespace bertini {
 
    namespace nag_datatype {

        template <typename T>
        using PointCont = std::deque<T>;
 
        using IndexT = typename PointCont<int>::size_type;  

        template<typename NumT, typename SystemT = System, template<typename> class ObjManagementP = policy::Copy >
        class WitnessSet
        {
            using PointP = ObjManagementP<Vec<NumT>>;
            using SliceP = ObjManagementP<Slice>;
            using SystemP = ObjManagementP<SystemT>;
 
            using PointContT = PointCont<typename PointP::HeldT>;
 
            PointContT points_;
            typename SliceP::HeldT slice_;
            typename SystemP::HeldT system_;
 
 
public:
            WitnessSet(){}

            WitnessSet(PointContT const& pts, typename SliceP::HeldT const& slc, typename SystemP::HeldT const& sys) :
                points_(pts),
                slice_(slc),
                system_(sys)
            {}
 

            inline
            auto Degree() const
            {
                return GetPoints().size();
            }
 

            inline
            auto Dimension() const
            {
                return GetSlice().Dimension();
            }
 

            inline
            void AddPoint(typename PointP::HeldT const& p)
            {
                points_.push_back(p);
            }
 

            void SetPoints(PointContT const& pts)
            {
                points_ = pts;
            }
 

            inline
            const PointContT& GetPoints() const
            {
                return points_;
            }

            const Vec<NumT>& GetPoint(IndexT ind) const
            {
                if (ind > Degree())
                {
                    std::stringstream ss;
                    ss << "asking for point of index " << ind << ", outside range [0,"<<Degree()-1 << "].";
                    throw std::runtime_error(ss.str());
                }
 
                return PointP::AtGet(points_[ind]);
            }
 

            const Vec<NumT>& operator[](IndexT ind) const
            {
                return PointP::AtGet(points_[ind]);
            }
 
 
 
 

            void SetSystem(typename SystemP::HeldT const& sys)
            {
                system_ = sys;
            }
 

            inline
            const SystemT& GetSystem() const
            {
                return SystemP::AtGet(system_);
            }
 

            void SetSlice(typename SliceP::HeldT const& s)
            {
                slice_ = s;
            }

            const Slice & GetSlice() const
            {
                return SliceP::AtGet(slice_);
            }

            bool IsConsistent() const
            {
                return (GetSystem().NumVariables() - GetSystem().NumNaturalFunctions()) == GetSlice().Dimension();
            }
 
 
        private:
 
            friend class boost::serialization::access;

            template <typename Archive>
            void save(Archive& ar, const unsigned /*version*/) const
            {
                ar & points_;
                ar & slice_;
                ar & system_;
            }
 
            template <typename Archive>
            void load(Archive& ar, const unsigned /*version*/)
            {
                ar & points_;
                ar & slice_;
                ar & system_;
                // GetSystem() is const and returns a const System&; Differentiate()/precision() are
                // const (they mutate only the system's mutable evaluation state), so this restores
                // the held system in place regardless of object-management policy.
                GetSystem().Differentiate();
                // the precision self-assignment that used to sit here (a re-materialize at the
                // value already held) is unnecessary: the first evaluation after load
                // materializes the system at the precision of the point it is given (#377)
            }
 
            BOOST_SERIALIZATION_SPLIT_MEMBER()
 
        };
    }
}