boost.cxx 0.0.2 → 1.90.1

package/boost/numeric/odeint/tools/assert.hpp

@@ -0,0 +1,30 @@
+//  (C) Copyright Matt Borland 2021 - 2023.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// We deliberately use assert in here:
+//
+// boost-no-inspect
+
+#ifndef BOOST_NUMERIC_ODEINT_TOOLS_ASSERT_HPP
+#define BOOST_NUMERIC_ODEINT_TOOLS_ASSERT_HPP
+
+#include <boost/numeric/odeint/tools/is_standalone.hpp>
+
+#ifndef BOOST_NUMERIC_ODEINT_STANDALONE
+
+#include <boost/assert.hpp>
+
+#define BOOST_NUMERIC_ODEINT_ASSERT(expr) BOOST_ASSERT(expr)
+#define BOOST_NUMERIC_ODEINT_ASSERT_MSG(expr, msg) BOOST_ASSERT_MSG(expr, msg)
+
+#else // Standalone mode so we use cassert
+
+#include <cassert>
+#define BOOST_NUMERIC_ODEINT_ASSERT(expr) assert(expr)
+#define BOOST_NUMERIC_ODEINT_ASSERT_MSG(expr, msg) assert((expr)&&(msg))
+
+#endif
+
+#endif //BOOST_NUMERIC_ODEINT_TOOLS_ASSERT_HPP

package/boost/numeric/odeint/tools/is_standalone.hpp

@@ -0,0 +1,21 @@
+//  Copyright Matt Borland 2021.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_NUMERIC_ODEINT_TOOLS_IS_STANDALONE_HPP
+#define BOOST_NUMERIC_ODEINT_TOOLS_IS_STANDALONE_HPP
+
+// If one or more of our required dependencies are missing assume we are
+// in standalone mode
+
+#ifdef __has_include
+#if !__has_include(<boost/config.hpp>) || !__has_include(<boost/assert.hpp>) || !__has_include(<boost/lexical_cast.hpp>) || \
+    !__has_include(<boost/throw_exception.hpp>) || !__has_include(<boost/predef/other/endian.h>)
+#   ifndef BOOST_NUMERIC_ODEINT_STANDALONE
+#       define BOOST_NUMERIC_ODEINT_STANDALONE
+#   endif
+#endif
+#endif
+
+#endif //BOOST_NUMERIC_ODEINT_TOOLS_IS_STANDALONE_HPP

package/boost/numeric/odeint/tools/traits.hpp

@@ -0,0 +1,39 @@
+//  Copyright Matt Borland 2021 - 2023.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_NUMERIC_ODEINT_TOOLS_TRAITS
+#define BOOST_NUMERIC_ODEINT_TOOLS_TRAITS
+
+#include <type_traits>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+#define BOOST_NUMERIC_ODEINT_HAS_NAMED_TRAIT(trait, name)               \
+template <typename T>                                                   \
+class trait                                                             \
+{                                                                       \
+private:                                                                \
+   using yes = char;                                                    \
+   struct no { char x[2]; };                                            \
+                                                                        \
+   template <typename U>                                                \
+   static yes test(typename U::name* = nullptr);                        \
+                                                                        \
+   template <typename U>                                                \
+   static no test(...);                                                 \
+                                                                        \
+public:                                                                 \
+   static constexpr bool value = (sizeof(test<T>(0)) == sizeof(char));  \
+};
+
+} //namespace detail
+} //namespace odeint
+} //namespace numeric
+} //namespace boost
+
+#endif //BOOST_NUMERIC_ODEINT_TOOLS_TRAITS

package/boost/numeric/odeint/util/bind.hpp

@@ -0,0 +1,35 @@
+/*
+ *     [begin_description]
+ *     Boost bind pull the placeholders, _1, _2, ... into global
+ *     namespace. This can conflict with the C++03 TR1 and C++11 
+ *     std::placeholders. This header provides a workaround for 
+ *     this problem.
+ *     [end_description]
+ *        
+ *     Copyright 2012 Christoph Koke
+ *     Copyright 2012 Karsten Ahnert
+ *           
+ *     Distributed under the Boost Software License, Version 1.0.
+ *     (See accompanying file LICENSE_1_0.txt or
+ *     copy at http://www.boost.org/LICENSE_1_0.txt)
+ * */
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED
+
+#include <functional>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+using std::bind;
+using namespace std::placeholders;
+
+} //namespace detail
+} //namespace odeint
+} //namespace numeric
+} //namespace boost
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_BIND_HPP_INCLUDED

package/boost/numeric/odeint/util/copy.hpp

@@ -0,0 +1,88 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/copy.hpp
+
+ [begin_description]
+ Copy abstraction for the usage in the steppers.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011-2012 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED
+
+#include <type_traits>
+
+#include <boost/range/algorithm/copy.hpp>
+
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/numeric/odeint/util/detail/is_range.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+namespace detail {
+
+    template< class Container1 , class Container2 >
+    void do_copying( const Container1 &from , Container2 &to , std::integral_constant<bool, true>)
+    {
+        boost::range::copy( from , boost::begin( to ) );
+    }
+
+    template< class Container1 , class Container2 >
+    void do_copying( const Container1 &from , Container2 &to , std::integral_constant<bool, false>)
+    {
+        to = from;
+    }
+
+} // namespace detail
+
+
+
+/*
+ * Default implementation of the copy operation used the assign operator
+ * gsl_vector must copied differently
+ */
+template< class Container1 , class Container2 , class Enabler = void >
+struct copy_impl_sfinae
+{
+    static void copy( const Container1 &from , Container2 &to )
+    {
+        typedef typename boost::numeric::odeint::detail::is_range< Container1 >::type is_range_type;
+        detail::do_copying( from , to , is_range_type() );
+    }
+
+};
+
+template< class Container1, class Container2 >
+struct copy_impl
+{
+    static void copy( const Container1 &from , Container2 &to )
+    {
+        copy_impl_sfinae< Container1 , Container2 >::copy( from , to );
+    }
+};
+
+// ToDo: allow also to copy INTO a range, not only from a range! Needs "const Container2 &to"
+template< class Container1 , class Container2 >
+void copy( const Container1 &from , Container2 &to )
+{
+    copy_impl< Container1 , Container2 >::copy( from , to );
+}
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_COPY_HPP_INCLUDED

package/boost/numeric/odeint/util/detail/is_range.hpp

@@ -0,0 +1,127 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/detail/is_range.hpp
+
+ [begin_description]
+ is_range implementation. Taken from the boost::range library.
+ [end_description]
+
+ Copyright 2011-2013 Karsten Ahnert
+ Copyright 2011-2013 Thorsten Ottosen
+
+
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED
+
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <cstddef>
+#include <type_traits>
+#include <boost/range/config.hpp>
+#include <boost/numeric/odeint/tools/traits.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+namespace detail {
+
+BOOST_NUMERIC_ODEINT_HAS_NAMED_TRAIT(has_iterator, iterator);
+BOOST_NUMERIC_ODEINT_HAS_NAMED_TRAIT(has_const_iterator, const_iterator);
+
+template< typename Range >
+struct is_range : std::integral_constant<bool, (has_iterator<Range>::value && has_const_iterator<Range>::value)>
+{
+};
+
+//////////////////////////////////////////////////////////////////////////
+// pair
+//////////////////////////////////////////////////////////////////////////
+
+template< typename iteratorT >
+struct is_range< std::pair<iteratorT,iteratorT> > : std::integral_constant<bool, true>
+{
+};
+
+template< typename iteratorT >
+struct is_range< const std::pair<iteratorT,iteratorT> > : std::integral_constant<bool, true>
+{
+};
+
+//////////////////////////////////////////////////////////////////////////
+// array
+//////////////////////////////////////////////////////////////////////////
+
+template< typename elementT, std::size_t sz >
+struct is_range< elementT[sz] > : std::integral_constant<bool, true>
+{
+};
+
+template< typename elementT, std::size_t sz >
+struct is_range< const elementT[sz] > : std::integral_constant<bool, true>
+{
+};
+
+//////////////////////////////////////////////////////////////////////////
+// string
+//////////////////////////////////////////////////////////////////////////
+
+template<>
+struct is_range< char* > : std::integral_constant<bool, true>
+{
+};
+
+template<>
+struct is_range< wchar_t* > : std::integral_constant<bool, true>
+{
+};
+
+template<>
+struct is_range< const char* > : std::integral_constant<bool, true>
+{
+};
+
+template<>
+struct is_range< const wchar_t* > : std::integral_constant<bool, true>
+{
+};
+
+template<>
+struct is_range< char* const > : std::integral_constant<bool, true>
+{
+};
+
+template<>
+struct is_range< wchar_t* const > : std::integral_constant<bool, true>
+{
+};
+
+template<>
+struct is_range< const char* const > : std::integral_constant<bool, true>
+{
+};
+
+template<>
+struct is_range< const wchar_t* const > : std::integral_constant<bool, true>
+{
+};
+
+} // namespace detail
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_DETAIL_IS_RANGE_HPP_INCLUDED

package/boost/numeric/odeint/util/detail/less_with_sign.hpp

@@ -0,0 +1,78 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/detail/less_with_sign.hpp
+
+ [begin_description]
+ Helper function to compare times taking into account the sign of dt
+ [end_description]
+
+ Copyright 2012-2015 Mario Mulansky
+ Copyright 2012 Karsten Ahnert
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_LESS_WITH_SIGN_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_INTEGRATE_DETAIL_LESS_WITH_SIGN_HPP_INCLUDED
+
+#include <limits>
+
+#include <boost/numeric/odeint/util/unit_helper.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+namespace detail {
+
+/**
+ * return t1 < t2 if dt > 0 and t1 > t2 if dt < 0 with epsilon accuracy
+ */
+template< typename T >
+bool less_with_sign( T t1 , T t2 , T dt )
+{
+    if( get_unit_value(dt) > 0 )
+        //return t1 < t2;
+        return t2-t1 > std::numeric_limits<T>::epsilon();
+    else
+        //return t1 > t2;
+        return t1-t2 > std::numeric_limits<T>::epsilon();
+}
+
+/**
+ * return t1 <= t2 if dt > 0 and t1 => t2 if dt < 0 with epsilon accuracy
+ */
+template< typename T >
+bool less_eq_with_sign( T t1 , T t2 , T dt )
+{
+    if( get_unit_value(dt) > 0 )
+        return t1-t2 <= std::numeric_limits<T>::epsilon();
+    else
+        return t2-t1 <= std::numeric_limits<T>::epsilon();
+}
+
+template< typename T >
+T min_abs( T t1 , T t2 )
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    if( get_unit_value(t1)>0 )
+        return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+    else
+        return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+}
+
+template< typename T >
+T max_abs( T t1 , T t2 )
+{
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    if( get_unit_value(t1)>0 )
+        return max BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+    else
+        return min BOOST_PREVENT_MACRO_SUBSTITUTION ( t1 , t2 );
+}
+} } } }
+
+#endif

package/boost/numeric/odeint/util/is_pair.hpp

@@ -0,0 +1,42 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/is_pair.hpp
+
+ [begin_description]
+ Metafunction to determine if a type is a std::pair<>.
+ [end_description]
+
+ Copyright 2011 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+
+template< class T >
+struct is_pair : public std::integral_constant<bool, false>
+{
+};
+
+template< class T1 , class T2 >
+struct is_pair< std::pair< T1 , T2 > > : public std::integral_constant<bool, true>
+{
+};
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED

package/boost/numeric/odeint/util/is_resizeable.hpp

@@ -0,0 +1,84 @@
+/*
+ [auto_generated]
+ boost/numeric/odeint/util/is_resizeable.hpp
+
+ [begin_description]
+ Metafunction to determine if a state type can resized. For usage in the steppers.
+ [end_description]
+
+ Copyright 2011-2012 Karsten Ahnert
+ Copyright 2011 Mario Mulansky
+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or
+ copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED
+#define BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED
+
+
+#include <vector>
+#include <type_traits>
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/front.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+   
+/*
+ * by default any type is not resizable
+ */
+template< typename Container , typename Enabler = void >
+struct is_resizeable_sfinae : std::false_type {};
+
+template< typename Container >
+struct is_resizeable : is_resizeable_sfinae< Container > {};
+
+
+
+/*
+ * specialization for std::vector
+ */
+template< class V, class A >
+struct is_resizeable< std::vector< V , A  > > : std::true_type {};
+
+
+/*
+ * sfinae specialization for fusion sequences
+ */
+template< typename FusionSequence >
+struct is_resizeable_sfinae<
+    FusionSequence ,
+    typename boost::enable_if< typename boost::fusion::traits::is_sequence< FusionSequence >::type >::type >
+{
+    typedef typename boost::mpl::find_if< FusionSequence , is_resizeable< boost::mpl::_1 > >::type iter;
+    typedef typename boost::mpl::end< FusionSequence >::type last;
+
+    typedef typename boost::mpl::if_< boost::is_same< iter , last > , std::false_type , std::true_type >::type type;
+    const static bool value = type::value;
+};
+
+
+
+
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_IS_RESIZEABLE_HPP_INCLUDED

package/boost/numeric/odeint/util/multi_array_adaption.hpp

@@ -0,0 +1,131 @@
+/*
+  [auto_generated]
+  boost/numeric/odeint/util/multi_array_adaption.hpp
+
+  [begin_description]
+  tba.
+  [end_description]
+
+  Copyright 2009-2012 Karsten Ahnert
+  Copyright 2009-2012 Mario Mulansky
+
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or
+  copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+
+#ifndef BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED
+#define BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED
+
+
+
+#include <boost/numeric/odeint/util/is_resizeable.hpp>
+#include <boost/numeric/odeint/util/resize.hpp>
+#include <boost/numeric/odeint/util/same_size.hpp>
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/multi_array.hpp>
+
+#include <type_traits>
+
+namespace boost {
+namespace numeric {
+namespace odeint {
+    
+template< typename T >
+struct is_multi_array
+{
+    typedef std::false_type type;
+    const static bool value = type::value;
+};
+    
+template< typename T >
+struct is_resizeable_multi_array
+{
+    typedef std::false_type type;
+    const static bool value = type::value;
+};
+
+
+
+template< typename V , size_t Dim , typename A >
+struct is_multi_array< boost::multi_array< V , Dim , A > >
+{
+    typedef std::true_type type;
+    const static bool value = type::value;
+};
+
+template< typename V , size_t Dim , typename A >
+struct is_resizeable_multi_array< boost::multi_array< V , Dim , A > >
+{
+    typedef std::true_type type;
+    const static bool value = type::value;
+};
+
+
+
+
+template< typename T  >
+struct is_resizeable_sfinae< T , typename boost::enable_if< typename is_resizeable_multi_array< T >::type >::type >
+{
+    typedef std::true_type type;
+    const static bool value = type::value;
+};
+
+
+
+
+
+template< typename T1 , typename T2  >
+struct same_size_impl_sfinae< T1 , T2 ,
+                       typename boost::enable_if<
+                           typename boost::mpl::and_< 
+                               is_multi_array< T1 > ,
+                               is_multi_array< T2 > ,
+                               boost::mpl::bool_< T1::dimensionality == T2::dimensionality >
+                           >::type
+                       >::type >
+{
+    static bool same_size( T1 const &x1 , T2 const &x2 )
+    {
+        for( size_t i=0 ; i<T1::dimensionality ; ++i )
+        {
+            if( x1.shape()[i] != x2.shape()[i] ) return false;
+            if( x1.index_bases()[i] != x2.index_bases()[i] ) return false;
+        }
+        return true;
+    }
+};
+
+
+template< typename T1 , typename T2 >
+struct resize_impl_sfinae< T1 , T2 ,
+                    typename boost::enable_if<
+                        typename boost::mpl::and_<
+                            is_resizeable_multi_array< T1 > ,
+                            is_multi_array< T2 > ,
+                            boost::mpl::bool_< T1::dimensionality == T2::dimensionality >
+                        >::type
+                    >::type >
+{
+    static void resize( T1 &x1 , const T2 &x2 )
+    {
+        std::array< int , T1::dimensionality > extents;
+        for( size_t i=0 ; i<T1::dimensionality ; ++i ) extents[i] = x2.shape()[i];
+        x1.resize( extents );
+        std::array< int , T1::dimensionality > origins;
+        for( size_t i=0 ; i<T1::dimensionality ; ++i ) origins[i] = x2.index_bases()[i];
+        x1.reindex( origins );
+    }
+};
+                            
+
+
+} // namespace odeint
+} // namespace numeric
+} // namespace boost
+
+
+#endif // BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED