@lakutata/math 0.0.0-stage → 3.1.5

package/vendor/symengine/symengine/type_codes.inc

@@ -0,0 +1,139 @@
+SYMENGINE_ENUM(SYMENGINE_INTEGER, Integer)
+SYMENGINE_ENUM(SYMENGINE_RATIONAL, Rational)
+SYMENGINE_ENUM(SYMENGINE_COMPLEX, Complex)
+SYMENGINE_ENUM(SYMENGINE_COMPLEX_DOUBLE, ComplexDouble)
+#if defined(HAVE_SYMENGINE_MPFR) || defined(SYMENGINE_INCLUDE_ALL)
+SYMENGINE_ENUM(SYMENGINE_REAL_MPFR, RealMPFR)
+#endif
+#if defined(HAVE_SYMENGINE_MPC) || defined(SYMENGINE_INCLUDE_ALL)
+SYMENGINE_ENUM(SYMENGINE_COMPLEX_MPC, ComplexMPC)
+#endif
+SYMENGINE_ENUM(SYMENGINE_REAL_DOUBLE, RealDouble)
+SYMENGINE_ENUM(SYMENGINE_INFTY, Infty)
+SYMENGINE_ENUM(SYMENGINE_NOT_A_NUMBER, NaN)
+#if defined(HAVE_SYMENGINE_PIRANHA) || defined(SYMENGINE_INCLUDE_ALL)
+SYMENGINE_ENUM(SYMENGINE_URATPSERIESPIRANHA, URatPSeriesPiranha)
+SYMENGINE_ENUM(SYMENGINE_UPSERIESPIRANHA, UPSeriesPiranha)
+#endif
+#if defined(HAVE_SYMENGINE_FLINT) || defined(SYMENGINE_INCLUDE_ALL)
+SYMENGINE_ENUM(SYMENGINE_URATPSERIESFLINT, URatPSeriesFlint)
+#endif
+SYMENGINE_ENUM(SYMENGINE_NUMBER_WRAPPER, NumberWrapper)
+// 'NUMBER_WRAPPER' returns the number of subclasses of Number.
+// All subclasses of Number must be added before it. Do not assign
+// non subclasses of Number before it.
+SYMENGINE_ENUM(SYMENGINE_SYMBOL, Symbol)
+SYMENGINE_ENUM(SYMENGINE_DUMMY, Dummy)
+SYMENGINE_ENUM(SYMENGINE_MUL, Mul)
+SYMENGINE_ENUM(SYMENGINE_ADD, Add)
+SYMENGINE_ENUM(SYMENGINE_POW, Pow)
+SYMENGINE_ENUM(SYMENGINE_UINTPOLY, UIntPoly)
+SYMENGINE_ENUM(SYMENGINE_MINTPOLY, MIntPoly)
+SYMENGINE_ENUM(SYMENGINE_URATPOLY, URatPoly)
+SYMENGINE_ENUM(SYMENGINE_UEXPRPOLY, UExprPoly)
+SYMENGINE_ENUM(SYMENGINE_MEXPRPOLY, MExprPoly)
+#if defined(HAVE_SYMENGINE_PIRANHA) || defined(SYMENGINE_INCLUDE_ALL)
+SYMENGINE_ENUM(SYMENGINE_UINTPOLYPIRANHA, UIntPolyPiranha)
+SYMENGINE_ENUM(SYMENGINE_URATPOLYPIRANHA, URatPolyPiranha)
+#endif
+#if defined(HAVE_SYMENGINE_FLINT) || defined(SYMENGINE_INCLUDE_ALL)
+SYMENGINE_ENUM(SYMENGINE_UINTPOLYFLINT, UIntPolyFlint)
+SYMENGINE_ENUM(SYMENGINE_URATPOLYFLINT, URatPolyFlint)
+#endif
+SYMENGINE_ENUM(SYMENGINE_GALOISFIELD, GaloisField)
+SYMENGINE_ENUM(SYMENGINE_UNIVARIATESERIES, UnivariateSeries)
+SYMENGINE_ENUM(SYMENGINE_LOG, Log)
+SYMENGINE_ENUM(SYMENGINE_CONJUGATE, Conjugate)
+SYMENGINE_ENUM(SYMENGINE_CONSTANT, Constant)
+SYMENGINE_ENUM(SYMENGINE_SIGN, Sign)
+SYMENGINE_ENUM(SYMENGINE_FLOOR, Floor)
+SYMENGINE_ENUM(SYMENGINE_CEILING, Ceiling)
+SYMENGINE_ENUM(SYMENGINE_SIN, Sin)
+SYMENGINE_ENUM(SYMENGINE_COS, Cos)
+SYMENGINE_ENUM(SYMENGINE_TAN, Tan)
+SYMENGINE_ENUM(SYMENGINE_COT, Cot)
+SYMENGINE_ENUM(SYMENGINE_CSC, Csc)
+SYMENGINE_ENUM(SYMENGINE_SEC, Sec)
+SYMENGINE_ENUM(SYMENGINE_ASIN, ASin)
+SYMENGINE_ENUM(SYMENGINE_ACOS, ACos)
+SYMENGINE_ENUM(SYMENGINE_ASEC, ASec)
+SYMENGINE_ENUM(SYMENGINE_ACSC, ACsc)
+SYMENGINE_ENUM(SYMENGINE_ATAN, ATan)
+SYMENGINE_ENUM(SYMENGINE_ACOT, ACot)
+SYMENGINE_ENUM(SYMENGINE_ATAN2, ATan2)
+SYMENGINE_ENUM(SYMENGINE_SINH, Sinh)
+SYMENGINE_ENUM(SYMENGINE_CSCH, Csch)
+SYMENGINE_ENUM(SYMENGINE_COSH, Cosh)
+SYMENGINE_ENUM(SYMENGINE_SECH, Sech)
+SYMENGINE_ENUM(SYMENGINE_TANH, Tanh)
+SYMENGINE_ENUM(SYMENGINE_COTH, Coth)
+SYMENGINE_ENUM(SYMENGINE_ASINH, ASinh)
+SYMENGINE_ENUM(SYMENGINE_ACSCH, ACsch)
+SYMENGINE_ENUM(SYMENGINE_ACOSH, ACosh)
+SYMENGINE_ENUM(SYMENGINE_ATANH, ATanh)
+SYMENGINE_ENUM(SYMENGINE_ACOTH, ACoth)
+SYMENGINE_ENUM(SYMENGINE_ASECH, ASech)
+SYMENGINE_ENUM(SYMENGINE_LAMBERTW, LambertW)
+SYMENGINE_ENUM(SYMENGINE_ZETA, Zeta)
+SYMENGINE_ENUM(SYMENGINE_DIRICHLET_ETA, Dirichlet_eta)
+SYMENGINE_ENUM(SYMENGINE_KRONECKERDELTA, KroneckerDelta)
+SYMENGINE_ENUM(SYMENGINE_LEVICIVITA, LeviCivita)
+SYMENGINE_ENUM(SYMENGINE_ERF, Erf)
+SYMENGINE_ENUM(SYMENGINE_ERFC, Erfc)
+SYMENGINE_ENUM(SYMENGINE_GAMMA, Gamma)
+SYMENGINE_ENUM(SYMENGINE_POLYGAMMA, PolyGamma)
+SYMENGINE_ENUM(SYMENGINE_LOWERGAMMA, LowerGamma)
+SYMENGINE_ENUM(SYMENGINE_UPPERGAMMA, UpperGamma)
+SYMENGINE_ENUM(SYMENGINE_LOGGAMMA, LogGamma)
+SYMENGINE_ENUM(SYMENGINE_BETA, Beta)
+SYMENGINE_ENUM(SYMENGINE_FUNCTIONSYMBOL, FunctionSymbol)
+SYMENGINE_ENUM(SYMENGINE_FUNCTIONWRAPPER, FunctionWrapper)
+SYMENGINE_ENUM(SYMENGINE_DERIVATIVE, Derivative)
+SYMENGINE_ENUM(SYMENGINE_SUBS, Subs)
+SYMENGINE_ENUM(SYMENGINE_ABS, Abs)
+SYMENGINE_ENUM(SYMENGINE_MAX, Max)
+SYMENGINE_ENUM(SYMENGINE_MIN, Min)
+SYMENGINE_ENUM(SYMENGINE_EMPTYSET, EmptySet)
+SYMENGINE_ENUM(SYMENGINE_FINITESET, FiniteSet)
+SYMENGINE_ENUM(SYMENGINE_INTERVAL, Interval)
+SYMENGINE_ENUM(SYMENGINE_COMPLEXES, Complexes)
+SYMENGINE_ENUM(SYMENGINE_REALS, Reals)
+SYMENGINE_ENUM(SYMENGINE_RATIONALS, Rationals)
+SYMENGINE_ENUM(SYMENGINE_INTEGERS, Integers)
+SYMENGINE_ENUM(SYMENGINE_NATURALS, Naturals)
+SYMENGINE_ENUM(SYMENGINE_NATURALS0, Naturals0)
+SYMENGINE_ENUM(SYMENGINE_CONDITIONSET, ConditionSet)
+SYMENGINE_ENUM(SYMENGINE_UNION, Union)
+SYMENGINE_ENUM(SYMENGINE_INTERSECTION, Intersection)
+SYMENGINE_ENUM(SYMENGINE_COMPLEMENT, Complement)
+SYMENGINE_ENUM(SYMENGINE_IMAGESET, ImageSet)
+SYMENGINE_ENUM(SYMENGINE_PIECEWISE, Piecewise)
+SYMENGINE_ENUM(SYMENGINE_UNIVERSALSET, UniversalSet)
+SYMENGINE_ENUM(SYMENGINE_CONTAINS, Contains)
+SYMENGINE_ENUM(SYMENGINE_BOOLEAN_ATOM, BooleanAtom)
+SYMENGINE_ENUM(SYMENGINE_NOT, Not)
+SYMENGINE_ENUM(SYMENGINE_AND, And)
+SYMENGINE_ENUM(SYMENGINE_OR, Or)
+SYMENGINE_ENUM(SYMENGINE_XOR, Xor)
+SYMENGINE_ENUM(SYMENGINE_EQUALITY, Equality)
+SYMENGINE_ENUM(SYMENGINE_UNEQUALITY, Unequality)
+SYMENGINE_ENUM(SYMENGINE_LESSTHAN, LessThan)
+SYMENGINE_ENUM(SYMENGINE_STRICTLESSTHAN, StrictLessThan)
+SYMENGINE_ENUM(SYMENGINE_TRUNCATE, Truncate)
+SYMENGINE_ENUM(SYMENGINE_PRIMEPI, PrimePi)
+SYMENGINE_ENUM(SYMENGINE_PRIMORIAL, Primorial)
+SYMENGINE_ENUM(SYMENGINE_TUPLE, Tuple)
+// IdentityMatrix must be the first MatrixExpr
+SYMENGINE_ENUM(SYMENGINE_IDENTITYMATRIX, IdentityMatrix)
+SYMENGINE_ENUM(SYMENGINE_ZEROMATRIX, ZeroMatrix)
+SYMENGINE_ENUM(SYMENGINE_MATRIXSYMBOL, MatrixSymbol)
+SYMENGINE_ENUM(SYMENGINE_DIAGONALMATRIX, DiagonalMatrix)
+SYMENGINE_ENUM(SYMENGINE_IMMUTABLEDENSEMATRIX, ImmutableDenseMatrix)
+SYMENGINE_ENUM(SYMENGINE_MATRIXADD, MatrixAdd)
+SYMENGINE_ENUM(SYMENGINE_MATRIXMUL, MatrixMul)
+SYMENGINE_ENUM(SYMENGINE_HADAMARDPRODUCT, HadamardProduct)
+SYMENGINE_ENUM(SYMENGINE_TRACE, Trace)
+SYMENGINE_ENUM(SYMENGINE_CONJUGATEMATRIX, ConjugateMatrix)
+SYMENGINE_ENUM(SYMENGINE_TRANSPOSE, Transpose)
+// Transpose must be the last MatrixExpr
+SYMENGINE_ENUM(SYMENGINE_UNEVALUATED_EXPR, UnevaluatedExpr)

package/vendor/symengine/symengine/utilities/cereal/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014, Randolph Voorhies, Shane Grant
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of cereal nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/vendor/symengine/symengine/utilities/cereal/include/cereal/access.hpp

@@ -0,0 +1,351 @@
+/*! \file access.hpp
+    \brief Access control and default construction */
+/*
+  Copyright (c) 2014, Randolph Voorhies, Shane Grant
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of cereal nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef CEREAL_ACCESS_HPP_
+#define CEREAL_ACCESS_HPP_
+
+#include <type_traits>
+#include <iostream>
+#include <cstdint>
+#include <functional>
+
+#include "cereal/macros.hpp"
+#include "cereal/specialize.hpp"
+#include "cereal/details/helpers.hpp"
+
+namespace cereal
+{
+  // ######################################################################
+  //! A class that allows cereal to load smart pointers to types that have no default constructor
+  /*! If your class does not have a default constructor, cereal will not be able
+      to load any smart pointers to it unless you overload LoadAndConstruct
+      for your class, and provide an appropriate load_and_construct method.  You can also
+      choose to define a member static function instead of specializing this class.
+
+      The specialization of LoadAndConstruct must be placed within the cereal namespace:
+
+      @code{.cpp}
+      struct MyType
+      {
+        MyType( int x ); // note: no default ctor
+        int myX;
+
+        // Define a serialize or load/save pair as you normally would
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( myX );
+        }
+      };
+
+      // Provide a specialization for LoadAndConstruct for your type
+      namespace cereal
+      {
+        template <> struct LoadAndConstruct<MyType>
+        {
+          // load_and_construct will be passed the archive that you will be loading
+          // from as well as a construct object which you can use as if it were the
+          // constructor for your type.  cereal will handle all memory management for you.
+          template <class Archive>
+          static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct )
+          {
+            int x;
+            ar( x );
+            construct( x );
+          }
+
+          // if you require versioning, simply add a const std::uint32_t as the final parameter, e.g.:
+          // load_and_construct( Archive & ar, cereal::construct<MyType> & construct, std::uint32_t const version )
+        };
+      } // end namespace cereal
+      @endcode
+
+      Please note that just as in using external serialization functions, you cannot get
+      access to non-public members of your class by befriending cereal::access.  If you
+      have the ability to modify the class you wish to serialize, it is recommended that you
+      use member serialize functions and a static member load_and_construct function.
+
+      load_and_construct functions, regardless of whether they are static members of your class or
+      whether you create one in the LoadAndConstruct specialization, have the following signature:
+
+      @code{.cpp}
+      // generally Archive will be templated, but it can be specific if desired
+      template <class Archive>
+      static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct );
+      // with an optional last parameter specifying the version: const std::uint32_t version
+      @endcode
+
+      Versioning behaves the same way as it does for standard serialization functions.
+
+      @tparam T The type to specialize for
+      @ingroup Access */
+  template <class T>
+  struct LoadAndConstruct
+  { };
+
+  // forward decl for construct
+  //! @cond PRIVATE_NEVERDEFINED
+  namespace memory_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
+  namespace boost_variant_detail{ template <class Ar, class T> struct LoadAndConstructLoadWrapper; }
+  //! @endcond
+
+  //! Used to construct types with no default constructor
+  /*! When serializing a type that has no default constructor, cereal
+      will attempt to call either the class static function load_and_construct
+      or the appropriate template specialization of LoadAndConstruct.  cereal
+      will pass that function a reference to the archive as well as a reference
+      to a construct object which should be used to perform the allocation once
+      data has been appropriately loaded.
+
+      @code{.cpp}
+      struct MyType
+      {
+        // note the lack of default constructor
+        MyType( int xx, int yy );
+
+        int x, y;
+        double notInConstructor;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        {
+          ar( x, y );
+          ar( notInConstructor );
+        }
+
+        template <class Archive>
+        static void load_and_construct( Archive & ar, cereal::construct<MyType> & construct )
+        {
+          int x, y;
+          ar( x, y );
+
+          // use construct object to initialize with loaded data
+          construct( x, y );
+
+          // access to member variables and functions via -> operator
+          ar( construct->notInConstructor );
+
+          // could also do the above section by:
+          double z;
+          ar( z );
+          construct->notInConstructor = z;
+        }
+      };
+      @endcode
+
+      @tparam T The class type being serialized
+      */
+  template <class T>
+  class construct
+  {
+    public:
+      //! Construct and initialize the type T with the given arguments
+      /*! This will forward all arguments to the underlying type T,
+          calling an appropriate constructor.
+
+          Calling this function more than once will result in an exception
+          being thrown.
+
+          @param args The arguments to the constructor for T
+          @throw Exception If called more than once */
+      template <class ... Args>
+      void operator()( Args && ... args );
+      // implementation deferred due to reliance on cereal::access
+
+      //! Get a reference to the initialized underlying object
+      /*! This must be called after the object has been initialized.
+
+          @return A reference to the initialized object
+          @throw Exception If called before initialization */
+      T * operator->()
+      {
+        if( !itsValid )
+          throw Exception("Object must be initialized prior to accessing members");
+
+        return itsPtr;
+      }
+
+      //! Returns a raw pointer to the initialized underlying object
+      /*! This is mainly intended for use with passing an instance of
+          a constructed object to cereal::base_class.
+
+          It is strongly recommended to avoid using this function in
+          any other circumstance.
+
+          @return A raw pointer to the initialized type */
+      T * ptr()
+      {
+        return operator->();
+      }
+
+    private:
+      template <class Ar, class TT> friend struct ::cereal::memory_detail::LoadAndConstructLoadWrapper;
+      template <class Ar, class TT> friend struct ::cereal::boost_variant_detail::LoadAndConstructLoadWrapper;
+
+      construct( T * p ) : itsPtr( p ), itsEnableSharedRestoreFunction( [](){} ), itsValid( false ) {}
+      construct( T * p, std::function<void()> enableSharedFunc ) : // g++4.7 ice with default lambda to std func
+        itsPtr( p ), itsEnableSharedRestoreFunction( enableSharedFunc ), itsValid( false ) {}
+      construct( construct const & ) = delete;
+      construct & operator=( construct const & ) = delete;
+
+      T * itsPtr;
+      std::function<void()> itsEnableSharedRestoreFunction;
+      bool itsValid;
+  };
+
+  // ######################################################################
+  //! A class that can be made a friend to give cereal access to non public functions
+  /*! If you desire non-public serialization functions within a class, cereal can only
+      access these if you declare cereal::access a friend.
+
+      @code{.cpp}
+      class MyClass
+      {
+        private:
+          friend class cereal::access; // gives access to the private serialize
+
+          template <class Archive>
+          void serialize( Archive & ar )
+          {
+            // some code
+          }
+      };
+      @endcode
+      @ingroup Access */
+  class access
+  {
+    public:
+      // ####### Standard Serialization ########################################
+      template<class Archive, class T> inline
+      static auto member_serialize(Archive & ar, T & t) -> decltype(t.CEREAL_SERIALIZE_FUNCTION_NAME(ar))
+      { return t.CEREAL_SERIALIZE_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save(Archive & ar, T const & t) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save_non_const(Archive & ar, T & t) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_load(Archive & ar, T & t) -> decltype(t.CEREAL_LOAD_FUNCTION_NAME(ar))
+      { return t.CEREAL_LOAD_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal(Archive const & ar, T const & t) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal_non_const(Archive const & ar, T & t) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar); }
+
+      template<class Archive, class T, class U> inline
+      static auto member_load_minimal(Archive const & ar, T & t, U && u) -> decltype(t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u)))
+      { return t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u)); }
+
+      // ####### Versioned Serialization #######################################
+      template<class Archive, class T> inline
+      static auto member_serialize(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_SERIALIZE_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SERIALIZE_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save(Archive & ar, T const & t, const std::uint32_t version ) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save_non_const(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_SAVE_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_load(Archive & ar, T & t, const std::uint32_t version ) -> decltype(t.CEREAL_LOAD_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_LOAD_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal(Archive const & ar, T const & t, const std::uint32_t version) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T> inline
+      static auto member_save_minimal_non_const(Archive const & ar, T & t, const std::uint32_t version) -> decltype(t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version))
+      { return t.CEREAL_SAVE_MINIMAL_FUNCTION_NAME(ar, version); }
+
+      template<class Archive, class T, class U> inline
+      static auto member_load_minimal(Archive const & ar, T & t, U && u, const std::uint32_t version) -> decltype(t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u), version))
+      { return t.CEREAL_LOAD_MINIMAL_FUNCTION_NAME(ar, std::forward<U>(u), version); }
+
+      // ####### Other Functionality ##########################################
+      // for detecting inheritance from enable_shared_from_this
+      template <class T> inline
+      static auto shared_from_this(T & t) -> decltype(t.shared_from_this());
+
+      // for placement new
+      template <class T, class ... Args> inline
+      static void construct( T *& ptr, Args && ... args )
+      {
+        new (ptr) T( std::forward<Args>( args )... );
+      }
+
+      // for non-placement new with a default constructor
+      template <class T> inline
+      static T * construct()
+      {
+        return new T();
+      }
+
+      template <class T> inline
+      static std::false_type load_and_construct(...)
+      { return std::false_type(); }
+
+      template<class T, class Archive> inline
+      static auto load_and_construct(Archive & ar, ::cereal::construct<T> & construct) -> decltype(T::load_and_construct(ar, construct))
+      {
+        T::load_and_construct( ar, construct );
+      }
+
+      template<class T, class Archive> inline
+      static auto load_and_construct(Archive & ar, ::cereal::construct<T> & construct, const std::uint32_t version) -> decltype(T::load_and_construct(ar, construct, version))
+      {
+        T::load_and_construct( ar, construct, version );
+      }
+  }; // end class access
+
+  // ######################################################################
+  // Deferred Implementation, see construct for more information
+  template <class T> template <class ... Args> inline
+  void construct<T>::operator()( Args && ... args )
+  {
+    if( itsValid )
+      throw Exception("Attempting to construct an already initialized object");
+
+    ::cereal::access::construct( itsPtr, std::forward<Args>( args )... );
+    itsEnableSharedRestoreFunction();
+    itsValid = true;
+  }
+} // namespace cereal
+
+#endif // CEREAL_ACCESS_HPP_

package/vendor/symengine/symengine/utilities/cereal/include/cereal/archives/adapters.hpp

@@ -0,0 +1,163 @@
+/*! \file adapters.hpp
+    \brief Archive adapters that provide additional functionality
+           on top of an existing archive */
+/*
+  Copyright (c) 2014, Randolph Voorhies, Shane Grant
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+      * Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+      * Neither the name of cereal nor the
+        names of its contributors may be used to endorse or promote products
+        derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef CEREAL_ARCHIVES_ADAPTERS_HPP_
+#define CEREAL_ARCHIVES_ADAPTERS_HPP_
+
+#include "cereal/details/helpers.hpp"
+#include <utility>
+
+namespace cereal
+{
+  #ifdef CEREAL_FUTURE_EXPERIMENTAL
+
+  // Forward declaration for friend access
+  template <class U, class A> U & get_user_data( A & );
+
+  //! Wraps an archive and gives access to user data
+  /*! This adapter is useful if you require access to
+      either raw pointers or references within your
+      serialization functions.
+
+      While cereal does not directly support serialization
+      raw pointers or references, it is sometimes the case
+      that you may want to supply something such as a raw
+      pointer or global reference to some constructor.
+      In this situation this adapter would likely be used
+      with the construct class to allow for non-default
+      constructors.
+
+      @note This feature is experimental and may be altered or removed in a future release. See issue #46.
+
+      @code{.cpp}
+      struct MyUserData
+      {
+        int * myRawPointer;
+        std::reference_wrapper<MyOtherType> myReference;
+      };
+
+      struct MyClass
+      {
+        // Note the raw pointer parameter
+        MyClass( int xx, int * rawP );
+
+        int x;
+
+        template <class Archive>
+        void serialize( Archive & ar )
+        { ar( x ); }
+
+        template <class Archive>
+        static void load_and_construct( Archive & ar, cereal::construct<MyClass> & construct )
+        {
+          int xx;
+          ar( xx );
+          // note the need to use get_user_data to retrieve user data from the archive
+          construct( xx, cereal::get_user_data<MyUserData>( ar ).myRawPointer );
+        }
+      };
+
+      int main()
+      {
+        {
+          MyUserData md;
+          md.myRawPointer = &something;
+          md.myReference = someInstanceOfType;
+
+          std::ifstream is( "data.xml" );
+          cereal::UserDataAdapter<MyUserData, cereal::XMLInputArchive> ar( md, is );
+
+          std::unique_ptr<MyClass> sc;
+          ar( sc ); // use as normal
+        }
+
+        return 0;
+      }
+      @endcode
+
+      @relates get_user_data
+
+      @tparam UserData The type to give the archive access to
+      @tparam Archive The archive to wrap */
+  template <class UserData, class Archive>
+  class UserDataAdapter : public Archive
+  {
+    public:
+      //! Construct the archive with some user data struct
+      /*! This will forward all arguments (other than the user
+          data) to the wrapped archive type.  The UserDataAdapter
+          can then be used identically to the wrapped archive type
+
+          @tparam Args The arguments to pass to the constructor of
+                       the archive. */
+      template <class ... Args>
+      UserDataAdapter( UserData & ud, Args && ... args ) :
+        Archive( std::forward<Args>( args )... ),
+        userdata( ud )
+      { }
+
+    private:
+      //! Overload the rtti function to enable dynamic_cast
+      void rtti() {}
+      friend UserData & get_user_data<UserData>( Archive & ar );
+      UserData & userdata; //!< The actual user data
+  };
+
+  //! Retrieves user data from an archive wrapped by UserDataAdapter
+  /*! This will attempt to retrieve the user data associated with
+      some archive wrapped by UserDataAdapter.  If this is used on
+      an archive that is not wrapped, a run-time exception will occur.
+
+      @note This feature is experimental and may be altered or removed in a future release. See issue #46.
+
+      @note The correct use of this function cannot be enforced at compile
+            time.
+
+      @relates UserDataAdapter
+      @tparam UserData The data struct contained in the archive
+      @tparam Archive The archive, which should be wrapped by UserDataAdapter
+      @param ar The archive
+      @throws Exception if the archive this is used upon is not wrapped with
+                        UserDataAdapter. */
+  template <class UserData, class Archive>
+  UserData & get_user_data( Archive & ar )
+  {
+    try
+    {
+      return dynamic_cast<UserDataAdapter<UserData, Archive> &>( ar ).userdata;
+    }
+    catch( std::bad_cast const & )
+    {
+      throw ::cereal::Exception("Attempting to get user data from archive not wrapped in UserDataAdapter");
+    }
+  }
+  #endif // CEREAL_FUTURE_EXPERIMENTAL
+} // namespace cereal
+
+#endif // CEREAL_ARCHIVES_ADAPTERS_HPP_