Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,37 @@
|
||||
set (SAMPLE_FILES
|
||||
FT8/170709_135615.wav
|
||||
ISCAT/ISCAT-A/VK7MO_110401_235515.wav
|
||||
ISCAT/ISCAT-B/K0AWU_100714_115000.wav
|
||||
JT4/JT4A/DF2ZC_070926_040700.WAV
|
||||
JT4/JT4F/OK1KIR_141105_175700.WAV
|
||||
JT65/JT65B/DL7UAE_040308_002400.wav
|
||||
JT9+JT65/130610_2343.wav
|
||||
JT9/130418_1742.wav
|
||||
MSK144/160915_113100.wav
|
||||
MSK144/160915_113230.wav
|
||||
QRA64/QRA64C/161113_0111.wav
|
||||
WSPR/150426_0918.wav
|
||||
)
|
||||
|
||||
set (contents_file_name contents_${WSJTX_VERSION_MAJOR}.${WSJTX_VERSION_MINOR}.json)
|
||||
set (contents_file ${CMAKE_CURRENT_BINARY_DIR}/${contents_file_name})
|
||||
set (web_tree ${CMAKE_CURRENT_BINARY_DIR}/web)
|
||||
set_source_files_properties (${contents_file} PROPERTIES GENERATED ON)
|
||||
|
||||
add_custom_command (
|
||||
OUTPUT ${contents_file}
|
||||
COMMAND ${CMAKE_COMMAND} ARGS -Dcontents_file=${contents_file} -DFILES="${SAMPLE_FILES}" -DDEST=${CMAKE_CURRENT_BINARY_DIR} -P make_contents.cmake
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
|
||||
DEPENDS ${SAMPLE_FILES} make_contents.cmake
|
||||
)
|
||||
|
||||
find_program (RSYNC_EXECUTABLE rsync)
|
||||
add_custom_command (
|
||||
OUTPUT upload.timestamp
|
||||
COMMAND ${CMAKE_COMMAND} ARGS -E copy_if_different ${contents_file} ${web_tree}/samples/${contents_file_name}
|
||||
COMMAND ${RSYNC_EXECUTABLE} ARGS -avz --progress ${CMAKE_CURRENT_BINARY_DIR}/web/samples ${PROJECT_SAMPLES_UPLOAD_DEST}
|
||||
COMMAND ${CMAKE_COMMAND} ARGS -E touch upload.timestamp
|
||||
DEPENDS ${contents_file}
|
||||
COMMENT "Uploading WSJT-X samples to web server"
|
||||
)
|
||||
add_custom_target (upload-samples DEPENDS upload.timestamp)
|
||||
@@ -0,0 +1,41 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/algebra/operations_dispatcher.hpp
|
||||
|
||||
[begin_description]
|
||||
Operations dispatcher to automatically chose suitable operations.
|
||||
[end_description]
|
||||
|
||||
Copyright 2013 Karsten Ahnert
|
||||
Copyright 2013 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_ALGEBRA_OPERATIONS_DISPATCHER_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_ALGEBRA_OPERATIONS_DISPATCHER_HPP_INCLUDED
|
||||
|
||||
#include <boost/numeric/odeint/algebra/default_operations.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
template< class StateType , class Enabler = void >
|
||||
struct operations_dispatcher_sfinae
|
||||
{
|
||||
typedef default_operations operations_type;
|
||||
};
|
||||
|
||||
template< class StateType >
|
||||
struct operations_dispatcher : operations_dispatcher_sfinae< StateType > {};
|
||||
|
||||
// no further specializations required
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,48 @@
|
||||
// (C) Copyright John Maddock 2007.
|
||||
// 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)
|
||||
//
|
||||
// This file is machine generated, do not edit by hand
|
||||
|
||||
// Polynomial evaluation using second order Horners rule
|
||||
#ifndef BOOST_MATH_TOOLS_POLY_EVAL_4_HPP
|
||||
#define BOOST_MATH_TOOLS_POLY_EVAL_4_HPP
|
||||
|
||||
namespace boost{ namespace math{ namespace tools{ namespace detail{
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(0);
|
||||
}
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(a[0]);
|
||||
}
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(a[1] * x + a[0]);
|
||||
}
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>((a[2] * x + a[1]) * x + a[0]);
|
||||
}
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]);
|
||||
}
|
||||
|
||||
|
||||
}}}} // namespaces
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
// (C) Copyright John Maddock 2001 - 2003.
|
||||
// (C) Copyright Jens Maurer 2003.
|
||||
// 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)
|
||||
|
||||
|
||||
// See http://www.boost.org for most recent version.
|
||||
|
||||
// SGI Irix specific config options:
|
||||
|
||||
#define BOOST_PLATFORM "SGI Irix"
|
||||
|
||||
#define BOOST_NO_SWPRINTF
|
||||
//
|
||||
// these are not auto detected by POSIX feature tests:
|
||||
//
|
||||
#define BOOST_HAS_GETTIMEOFDAY
|
||||
#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
|
||||
|
||||
#ifdef __GNUC__
|
||||
// GNU C on IRIX does not support threads (checked up to gcc 3.3)
|
||||
# define BOOST_DISABLE_THREADS
|
||||
#endif
|
||||
|
||||
// boilerplate code:
|
||||
#define BOOST_HAS_UNISTD_H
|
||||
#include <boost/config/posix_features.hpp>
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(BOOST_FUSION_BEGIN_IMPL_09272006_0719)
|
||||
#define BOOST_FUSION_BEGIN_IMPL_09272006_0719
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/adapted/boost_tuple/boost_tuple_iterator.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct boost_tuple_tag;
|
||||
|
||||
namespace extension
|
||||
{
|
||||
template<typename T>
|
||||
struct begin_impl;
|
||||
|
||||
template <>
|
||||
struct begin_impl<boost_tuple_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef boost_tuple_iterator<Sequence> type;
|
||||
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
static type
|
||||
call(Sequence& v)
|
||||
{
|
||||
return type(v);
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,91 @@
|
||||
// Copyright David Abrahams 2002.
|
||||
// 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 DEFAULT_CALL_POLICIES_DWA2002131_HPP
|
||||
# define DEFAULT_CALL_POLICIES_DWA2002131_HPP
|
||||
|
||||
# include <boost/python/detail/prefix.hpp>
|
||||
# include <boost/mpl/if.hpp>
|
||||
# include <boost/python/to_python_value.hpp>
|
||||
# include <boost/python/detail/value_arg.hpp>
|
||||
# include <boost/type_traits/transform_traits.hpp>
|
||||
# include <boost/type_traits/is_pointer.hpp>
|
||||
# include <boost/type_traits/is_reference.hpp>
|
||||
# include <boost/mpl/or.hpp>
|
||||
# include <boost/mpl/front.hpp>
|
||||
|
||||
namespace boost { namespace python {
|
||||
|
||||
template <class T> struct to_python_value;
|
||||
|
||||
namespace detail
|
||||
{
|
||||
// for "readable" error messages
|
||||
template <class T> struct specify_a_return_value_policy_to_wrap_functions_returning
|
||||
# if defined(__GNUC__) || defined(__EDG__)
|
||||
{}
|
||||
# endif
|
||||
;
|
||||
}
|
||||
|
||||
struct default_result_converter;
|
||||
|
||||
struct default_call_policies
|
||||
{
|
||||
// Ownership of this argument tuple will ultimately be adopted by
|
||||
// the caller.
|
||||
template <class ArgumentPackage>
|
||||
static bool precall(ArgumentPackage const&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
// Pass the result through
|
||||
template <class ArgumentPackage>
|
||||
static PyObject* postcall(ArgumentPackage const&, PyObject* result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
typedef default_result_converter result_converter;
|
||||
typedef PyObject* argument_package;
|
||||
|
||||
template <class Sig>
|
||||
struct extract_return_type : mpl::front<Sig>
|
||||
{
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
struct default_result_converter
|
||||
{
|
||||
template <class R>
|
||||
struct apply
|
||||
{
|
||||
typedef typename mpl::if_<
|
||||
mpl::or_<is_pointer<R>, is_reference<R> >
|
||||
, detail::specify_a_return_value_policy_to_wrap_functions_returning<R>
|
||||
, boost::python::to_python_value<
|
||||
typename detail::value_arg<R>::type
|
||||
>
|
||||
>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
// Exceptions for c strings an PyObject*s
|
||||
template <>
|
||||
struct default_result_converter::apply<char const*>
|
||||
{
|
||||
typedef boost::python::to_python_value<char const*const&> type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct default_result_converter::apply<PyObject*>
|
||||
{
|
||||
typedef boost::python::to_python_value<PyObject*const&> type;
|
||||
};
|
||||
|
||||
}} // namespace boost::python
|
||||
|
||||
#endif // DEFAULT_CALL_POLICIES_DWA2002131_HPP
|
||||
@@ -0,0 +1,509 @@
|
||||
#ifndef _DATE_TIME_INT_ADAPTER_HPP__
|
||||
#define _DATE_TIME_INT_ADAPTER_HPP__
|
||||
|
||||
/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
|
||||
* Use, modification and distribution is subject to the
|
||||
* Boost Software License, Version 1.0. (See accompanying
|
||||
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
|
||||
* Author: Jeff Garland, Bart Garst
|
||||
* $Date$
|
||||
*/
|
||||
|
||||
|
||||
#include "boost/config.hpp"
|
||||
#include "boost/limits.hpp" //work around compilers without limits
|
||||
#include "boost/date_time/special_defs.hpp"
|
||||
#include "boost/date_time/locale_config.hpp"
|
||||
#ifndef BOOST_DATE_TIME_NO_LOCALE
|
||||
# include <ostream>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace date_time {
|
||||
|
||||
|
||||
//! Adapter to create integer types with +-infinity, and not a value
|
||||
/*! This class is used internally in counted date/time representations.
|
||||
* It adds the floating point like features of infinities and
|
||||
* not a number. It also provides mathmatical operations with
|
||||
* consideration to special values following these rules:
|
||||
*@code
|
||||
* +infinity - infinity == Not A Number (NAN)
|
||||
* infinity * non-zero == infinity
|
||||
* infinity * zero == NAN
|
||||
* +infinity * -integer == -infinity
|
||||
* infinity / infinity == NAN
|
||||
* infinity * infinity == infinity
|
||||
*@endcode
|
||||
*/
|
||||
template<typename int_type_>
|
||||
class int_adapter {
|
||||
public:
|
||||
typedef int_type_ int_type;
|
||||
int_adapter(int_type v) :
|
||||
value_(v)
|
||||
{}
|
||||
static bool has_infinity()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
static const int_adapter pos_infinity()
|
||||
{
|
||||
return (::std::numeric_limits<int_type>::max)();
|
||||
}
|
||||
static const int_adapter neg_infinity()
|
||||
{
|
||||
return (::std::numeric_limits<int_type>::min)();
|
||||
}
|
||||
static const int_adapter not_a_number()
|
||||
{
|
||||
return (::std::numeric_limits<int_type>::max)()-1;
|
||||
}
|
||||
static int_adapter max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||||
{
|
||||
return (::std::numeric_limits<int_type>::max)()-2;
|
||||
}
|
||||
static int_adapter min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||||
{
|
||||
return (::std::numeric_limits<int_type>::min)()+1;
|
||||
}
|
||||
static int_adapter from_special(special_values sv)
|
||||
{
|
||||
switch (sv) {
|
||||
case not_a_date_time: return not_a_number();
|
||||
case neg_infin: return neg_infinity();
|
||||
case pos_infin: return pos_infinity();
|
||||
case max_date_time: return (max)();
|
||||
case min_date_time: return (min)();
|
||||
default: return not_a_number();
|
||||
}
|
||||
}
|
||||
static bool is_inf(int_type v)
|
||||
{
|
||||
return (v == neg_infinity().as_number() ||
|
||||
v == pos_infinity().as_number());
|
||||
}
|
||||
static bool is_neg_inf(int_type v)
|
||||
{
|
||||
return (v == neg_infinity().as_number());
|
||||
}
|
||||
static bool is_pos_inf(int_type v)
|
||||
{
|
||||
return (v == pos_infinity().as_number());
|
||||
}
|
||||
static bool is_not_a_number(int_type v)
|
||||
{
|
||||
return (v == not_a_number().as_number());
|
||||
}
|
||||
//! Returns either special value type or is_not_special
|
||||
static special_values to_special(int_type v)
|
||||
{
|
||||
if (is_not_a_number(v)) return not_a_date_time;
|
||||
if (is_neg_inf(v)) return neg_infin;
|
||||
if (is_pos_inf(v)) return pos_infin;
|
||||
return not_special;
|
||||
}
|
||||
|
||||
//-3 leaves room for representations of infinity and not a date
|
||||
static int_type maxcount()
|
||||
{
|
||||
return (::std::numeric_limits<int_type>::max)()-3;
|
||||
}
|
||||
bool is_infinity() const
|
||||
{
|
||||
return (value_ == neg_infinity().as_number() ||
|
||||
value_ == pos_infinity().as_number());
|
||||
}
|
||||
bool is_pos_infinity()const
|
||||
{
|
||||
return(value_ == pos_infinity().as_number());
|
||||
}
|
||||
bool is_neg_infinity()const
|
||||
{
|
||||
return(value_ == neg_infinity().as_number());
|
||||
}
|
||||
bool is_nan() const
|
||||
{
|
||||
return (value_ == not_a_number().as_number());
|
||||
}
|
||||
bool is_special() const
|
||||
{
|
||||
return(is_infinity() || is_nan());
|
||||
}
|
||||
bool operator==(const int_adapter& rhs) const
|
||||
{
|
||||
return (compare(rhs) == 0);
|
||||
}
|
||||
bool operator==(const int& rhs) const
|
||||
{
|
||||
// quiets compiler warnings
|
||||
bool is_signed = std::numeric_limits<int_type>::is_signed;
|
||||
if(!is_signed)
|
||||
{
|
||||
if(is_neg_inf(value_) && rhs == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return (compare(rhs) == 0);
|
||||
}
|
||||
bool operator!=(const int_adapter& rhs) const
|
||||
{
|
||||
return (compare(rhs) != 0);
|
||||
}
|
||||
bool operator!=(const int& rhs) const
|
||||
{
|
||||
// quiets compiler warnings
|
||||
bool is_signed = std::numeric_limits<int_type>::is_signed;
|
||||
if(!is_signed)
|
||||
{
|
||||
if(is_neg_inf(value_) && rhs == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return (compare(rhs) != 0);
|
||||
}
|
||||
bool operator<(const int_adapter& rhs) const
|
||||
{
|
||||
return (compare(rhs) == -1);
|
||||
}
|
||||
bool operator<(const int& rhs) const
|
||||
{
|
||||
// quiets compiler warnings
|
||||
bool is_signed = std::numeric_limits<int_type>::is_signed;
|
||||
if(!is_signed)
|
||||
{
|
||||
if(is_neg_inf(value_) && rhs == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return (compare(rhs) == -1);
|
||||
}
|
||||
bool operator>(const int_adapter& rhs) const
|
||||
{
|
||||
return (compare(rhs) == 1);
|
||||
}
|
||||
int_type as_number() const
|
||||
{
|
||||
return value_;
|
||||
}
|
||||
//! Returns either special value type or is_not_special
|
||||
special_values as_special() const
|
||||
{
|
||||
return int_adapter::to_special(value_);
|
||||
}
|
||||
//creates nasty ambiguities
|
||||
// operator int_type() const
|
||||
// {
|
||||
// return value_;
|
||||
// }
|
||||
|
||||
/*! Operator allows for adding dissimilar int_adapter types.
|
||||
* The return type will match that of the the calling object's type */
|
||||
template<class rhs_type>
|
||||
inline
|
||||
int_adapter operator+(const int_adapter<rhs_type>& rhs) const
|
||||
{
|
||||
if(is_special() || rhs.is_special())
|
||||
{
|
||||
if (is_nan() || rhs.is_nan())
|
||||
{
|
||||
return int_adapter::not_a_number();
|
||||
}
|
||||
if((is_pos_inf(value_) && rhs.is_neg_inf(rhs.as_number())) ||
|
||||
(is_neg_inf(value_) && rhs.is_pos_inf(rhs.as_number())) )
|
||||
{
|
||||
return int_adapter::not_a_number();
|
||||
}
|
||||
if (is_infinity())
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
if (rhs.is_pos_inf(rhs.as_number()))
|
||||
{
|
||||
return int_adapter::pos_infinity();
|
||||
}
|
||||
if (rhs.is_neg_inf(rhs.as_number()))
|
||||
{
|
||||
return int_adapter::neg_infinity();
|
||||
}
|
||||
}
|
||||
return int_adapter<int_type>(value_ + static_cast<int_type>(rhs.as_number()));
|
||||
}
|
||||
|
||||
int_adapter operator+(const int_type rhs) const
|
||||
{
|
||||
if(is_special())
|
||||
{
|
||||
if (is_nan())
|
||||
{
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
if (is_infinity())
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
return int_adapter<int_type>(value_ + rhs);
|
||||
}
|
||||
|
||||
/*! Operator allows for subtracting dissimilar int_adapter types.
|
||||
* The return type will match that of the the calling object's type */
|
||||
template<class rhs_type>
|
||||
inline
|
||||
int_adapter operator-(const int_adapter<rhs_type>& rhs)const
|
||||
{
|
||||
if(is_special() || rhs.is_special())
|
||||
{
|
||||
if (is_nan() || rhs.is_nan())
|
||||
{
|
||||
return int_adapter::not_a_number();
|
||||
}
|
||||
if((is_pos_inf(value_) && rhs.is_pos_inf(rhs.as_number())) ||
|
||||
(is_neg_inf(value_) && rhs.is_neg_inf(rhs.as_number())) )
|
||||
{
|
||||
return int_adapter::not_a_number();
|
||||
}
|
||||
if (is_infinity())
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
if (rhs.is_pos_inf(rhs.as_number()))
|
||||
{
|
||||
return int_adapter::neg_infinity();
|
||||
}
|
||||
if (rhs.is_neg_inf(rhs.as_number()))
|
||||
{
|
||||
return int_adapter::pos_infinity();
|
||||
}
|
||||
}
|
||||
return int_adapter<int_type>(value_ - static_cast<int_type>(rhs.as_number()));
|
||||
}
|
||||
int_adapter operator-(const int_type rhs) const
|
||||
{
|
||||
if(is_special())
|
||||
{
|
||||
if (is_nan())
|
||||
{
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
if (is_infinity())
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
return int_adapter<int_type>(value_ - rhs);
|
||||
}
|
||||
|
||||
// should templatize this to be consistant with op +-
|
||||
int_adapter operator*(const int_adapter& rhs)const
|
||||
{
|
||||
if(this->is_special() || rhs.is_special())
|
||||
{
|
||||
return mult_div_specials(rhs);
|
||||
}
|
||||
return int_adapter<int_type>(value_ * rhs.value_);
|
||||
}
|
||||
/*! Provided for cases when automatic conversion from
|
||||
* 'int' to 'int_adapter' causes incorrect results. */
|
||||
int_adapter operator*(const int rhs) const
|
||||
{
|
||||
if(is_special())
|
||||
{
|
||||
return mult_div_specials(rhs);
|
||||
}
|
||||
return int_adapter<int_type>(value_ * rhs);
|
||||
}
|
||||
|
||||
// should templatize this to be consistant with op +-
|
||||
int_adapter operator/(const int_adapter& rhs)const
|
||||
{
|
||||
if(this->is_special() || rhs.is_special())
|
||||
{
|
||||
if(is_infinity() && rhs.is_infinity())
|
||||
{
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
if(rhs != 0)
|
||||
{
|
||||
return mult_div_specials(rhs);
|
||||
}
|
||||
else { // let divide by zero blow itself up
|
||||
return int_adapter<int_type>(value_ / rhs.value_);
|
||||
}
|
||||
}
|
||||
return int_adapter<int_type>(value_ / rhs.value_);
|
||||
}
|
||||
/*! Provided for cases when automatic conversion from
|
||||
* 'int' to 'int_adapter' causes incorrect results. */
|
||||
int_adapter operator/(const int rhs) const
|
||||
{
|
||||
if(is_special() && rhs != 0)
|
||||
{
|
||||
return mult_div_specials(rhs);
|
||||
}
|
||||
return int_adapter<int_type>(value_ / rhs);
|
||||
}
|
||||
|
||||
// should templatize this to be consistant with op +-
|
||||
int_adapter operator%(const int_adapter& rhs)const
|
||||
{
|
||||
if(this->is_special() || rhs.is_special())
|
||||
{
|
||||
if(is_infinity() && rhs.is_infinity())
|
||||
{
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
if(rhs != 0)
|
||||
{
|
||||
return mult_div_specials(rhs);
|
||||
}
|
||||
else { // let divide by zero blow itself up
|
||||
return int_adapter<int_type>(value_ % rhs.value_);
|
||||
}
|
||||
}
|
||||
return int_adapter<int_type>(value_ % rhs.value_);
|
||||
}
|
||||
/*! Provided for cases when automatic conversion from
|
||||
* 'int' to 'int_adapter' causes incorrect results. */
|
||||
int_adapter operator%(const int rhs) const
|
||||
{
|
||||
if(is_special() && rhs != 0)
|
||||
{
|
||||
return mult_div_specials(rhs);
|
||||
}
|
||||
return int_adapter<int_type>(value_ % rhs);
|
||||
}
|
||||
private:
|
||||
int_type value_;
|
||||
|
||||
//! returns -1, 0, 1, or 2 if 'this' is <, ==, >, or 'nan comparison' rhs
|
||||
int compare(const int_adapter& rhs)const
|
||||
{
|
||||
if(this->is_special() || rhs.is_special())
|
||||
{
|
||||
if(this->is_nan() || rhs.is_nan()) {
|
||||
if(this->is_nan() && rhs.is_nan()) {
|
||||
return 0; // equal
|
||||
}
|
||||
else {
|
||||
return 2; // nan
|
||||
}
|
||||
}
|
||||
if((is_neg_inf(value_) && !is_neg_inf(rhs.value_)) ||
|
||||
(is_pos_inf(rhs.value_) && !is_pos_inf(value_)) )
|
||||
{
|
||||
return -1; // less than
|
||||
}
|
||||
if((is_pos_inf(value_) && !is_pos_inf(rhs.value_)) ||
|
||||
(is_neg_inf(rhs.value_) && !is_neg_inf(value_)) ) {
|
||||
return 1; // greater than
|
||||
}
|
||||
}
|
||||
if(value_ < rhs.value_) return -1;
|
||||
if(value_ > rhs.value_) return 1;
|
||||
// implied-> if(value_ == rhs.value_)
|
||||
return 0;
|
||||
}
|
||||
/* When multiplying and dividing with at least 1 special value
|
||||
* very simmilar rules apply. In those cases where the rules
|
||||
* are different, they are handled in the respective operator
|
||||
* function. */
|
||||
//! Assumes at least 'this' or 'rhs' is a special value
|
||||
int_adapter mult_div_specials(const int_adapter& rhs)const
|
||||
{
|
||||
int min_value;
|
||||
// quiets compiler warnings
|
||||
bool is_signed = std::numeric_limits<int_type>::is_signed;
|
||||
if(is_signed) {
|
||||
min_value = 0;
|
||||
}
|
||||
else {
|
||||
min_value = 1;// there is no zero with unsigned
|
||||
}
|
||||
if(this->is_nan() || rhs.is_nan()) {
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) {
|
||||
return int_adapter<int_type>(pos_infinity());
|
||||
}
|
||||
if((*this > 0 && rhs < min_value) || (*this < min_value && rhs > 0)) {
|
||||
return int_adapter<int_type>(neg_infinity());
|
||||
}
|
||||
//implied -> if(this->value_ == 0 || rhs.value_ == 0)
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
/* Overloaded function necessary because of special
|
||||
* situation where int_adapter is instantiated with
|
||||
* 'unsigned' and func is called with negative int.
|
||||
* It would produce incorrect results since 'unsigned'
|
||||
* wraps around when initialized with a negative value */
|
||||
//! Assumes 'this' is a special value
|
||||
int_adapter mult_div_specials(const int& rhs) const
|
||||
{
|
||||
int min_value;
|
||||
// quiets compiler warnings
|
||||
bool is_signed = std::numeric_limits<int_type>::is_signed;
|
||||
if(is_signed) {
|
||||
min_value = 0;
|
||||
}
|
||||
else {
|
||||
min_value = 1;// there is no zero with unsigned
|
||||
}
|
||||
if(this->is_nan()) {
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) {
|
||||
return int_adapter<int_type>(pos_infinity());
|
||||
}
|
||||
if((*this > 0 && rhs < 0) || (*this < min_value && rhs > 0)) {
|
||||
return int_adapter<int_type>(neg_infinity());
|
||||
}
|
||||
//implied -> if(this->value_ == 0 || rhs.value_ == 0)
|
||||
return int_adapter<int_type>(not_a_number());
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#ifndef BOOST_DATE_TIME_NO_LOCALE
|
||||
/*! Expected output is either a numeric representation
|
||||
* or a special values representation.<BR>
|
||||
* Ex. "12", "+infinity", "not-a-number", etc. */
|
||||
//template<class charT = char, class traits = std::traits<charT>, typename int_type>
|
||||
template<class charT, class traits, typename int_type>
|
||||
inline
|
||||
std::basic_ostream<charT, traits>&
|
||||
operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
|
||||
{
|
||||
if(ia.is_special()) {
|
||||
// switch copied from date_names_put.hpp
|
||||
switch(ia.as_special())
|
||||
{
|
||||
case not_a_date_time:
|
||||
os << "not-a-number";
|
||||
break;
|
||||
case pos_infin:
|
||||
os << "+infinity";
|
||||
break;
|
||||
case neg_infin:
|
||||
os << "-infinity";
|
||||
break;
|
||||
default:
|
||||
os << "";
|
||||
}
|
||||
}
|
||||
else {
|
||||
os << ia.as_number();
|
||||
}
|
||||
return os;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
} } //namespace date_time
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,9 @@
|
||||
0; 0; 0
|
||||
0; 0; 64
|
||||
0; 0;128
|
||||
0; 0;217
|
||||
150;147; 92
|
||||
183;186; 46
|
||||
225;228;107
|
||||
255;255; 0
|
||||
255; 51; 0
|
||||
@@ -0,0 +1,252 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
template<typename Key, typename Value, typename Rest>
|
||||
struct keyed_element;
|
||||
struct nil_keyed_element;
|
||||
template<typename N, typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_>
|
||||
struct deque_keyed_values_impl;
|
||||
template<typename N>
|
||||
struct deque_keyed_values_impl<N, void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_>
|
||||
{
|
||||
typedef nil_keyed_element type;
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct()
|
||||
{
|
||||
return type();
|
||||
}
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_()
|
||||
{
|
||||
return type();
|
||||
}
|
||||
};
|
||||
template<typename N, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
struct deque_keyed_values_impl
|
||||
{
|
||||
typedef mpl::int_<mpl::plus<N, mpl::int_<1> >::value> next_index;
|
||||
typedef typename deque_keyed_values_impl<
|
||||
next_index,
|
||||
T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>::type tail;
|
||||
typedef keyed_element<N, T0, tail> type;
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
>::construct());
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
>::forward_());
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1
|
||||
>::construct(t1));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1
|
||||
>::forward_(std::forward<T_1>( t1)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2
|
||||
>::construct(t1 , t2));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2 , typename detail::call_param<T3 >::type t3)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3
|
||||
>::construct(t1 , t2 , t3));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2 , typename T_3>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2 , T_3
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2) , std::forward<T_3>( t3)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2 , typename detail::call_param<T3 >::type t3 , typename detail::call_param<T4 >::type t4)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4
|
||||
>::construct(t1 , t2 , t3 , t4));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2 , typename T_3 , typename T_4>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2 , T_3 , T_4
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2) , std::forward<T_3>( t3) , std::forward<T_4>( t4)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2 , typename detail::call_param<T3 >::type t3 , typename detail::call_param<T4 >::type t4 , typename detail::call_param<T5 >::type t5)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5
|
||||
>::construct(t1 , t2 , t3 , t4 , t5));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2 , typename T_3 , typename T_4 , typename T_5>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2 , T_3 , T_4 , T_5
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2) , std::forward<T_3>( t3) , std::forward<T_4>( t4) , std::forward<T_5>( t5)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2 , typename detail::call_param<T3 >::type t3 , typename detail::call_param<T4 >::type t4 , typename detail::call_param<T5 >::type t5 , typename detail::call_param<T6 >::type t6)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2 , typename T_3 , typename T_4 , typename T_5 , typename T_6>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_6 && t6)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2 , T_3 , T_4 , T_5 , T_6
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2) , std::forward<T_3>( t3) , std::forward<T_4>( t4) , std::forward<T_5>( t5) , std::forward<T_6>( t6)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2 , typename detail::call_param<T3 >::type t3 , typename detail::call_param<T4 >::type t4 , typename detail::call_param<T5 >::type t5 , typename detail::call_param<T6 >::type t6 , typename detail::call_param<T7 >::type t7)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2 , typename T_3 , typename T_4 , typename T_5 , typename T_6 , typename T_7>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_6 && t6 , T_7 && t7)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2 , T_3 , T_4 , T_5 , T_6 , T_7
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2) , std::forward<T_3>( t3) , std::forward<T_4>( t4) , std::forward<T_5>( t5) , std::forward<T_6>( t6) , std::forward<T_7>( t7)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2 , typename detail::call_param<T3 >::type t3 , typename detail::call_param<T4 >::type t4 , typename detail::call_param<T5 >::type t5 , typename detail::call_param<T6 >::type t6 , typename detail::call_param<T7 >::type t7 , typename detail::call_param<T8 >::type t8)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2 , typename T_3 , typename T_4 , typename T_5 , typename T_6 , typename T_7 , typename T_8>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_6 && t6 , T_7 && t7 , T_8 && t8)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2 , T_3 , T_4 , T_5 , T_6 , T_7 , T_8
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2) , std::forward<T_3>( t3) , std::forward<T_4>( t4) , std::forward<T_5>( t5) , std::forward<T_6>( t6) , std::forward<T_7>( t7) , std::forward<T_8>( t8)));
|
||||
}
|
||||
# endif
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type construct(typename detail::call_param<T0 >::type t0 , typename detail::call_param<T1 >::type t1 , typename detail::call_param<T2 >::type t2 , typename detail::call_param<T3 >::type t3 , typename detail::call_param<T4 >::type t4 , typename detail::call_param<T5 >::type t5 , typename detail::call_param<T6 >::type t6 , typename detail::call_param<T7 >::type t7 , typename detail::call_param<T8 >::type t8 , typename detail::call_param<T9 >::type t9)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9));
|
||||
}
|
||||
# if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template <typename T_0 , typename T_1 , typename T_2 , typename T_3 , typename T_4 , typename T_5 , typename T_6 , typename T_7 , typename T_8 , typename T_9>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type forward_(T_0 && t0 , T_1 && t1 , T_2 && t2 , T_3 && t3 , T_4 && t4 , T_5 && t5 , T_6 && t6 , T_7 && t7 , T_8 && t8 , T_9 && t9)
|
||||
{
|
||||
return type(std::forward<T_0>( t0),
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T_1 , T_2 , T_3 , T_4 , T_5 , T_6 , T_7 , T_8 , T_9
|
||||
>::forward_(std::forward<T_1>( t1) , std::forward<T_2>( t2) , std::forward<T_3>( t3) , std::forward<T_4>( t4) , std::forward<T_5>( t5) , std::forward<T_6>( t6) , std::forward<T_7>( t7) , std::forward<T_8>( t8) , std::forward<T_9>( t9)));
|
||||
}
|
||||
# endif
|
||||
};
|
||||
template<typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_>
|
||||
struct deque_keyed_values
|
||||
: deque_keyed_values_impl<mpl::int_<0>, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
|
||||
{};
|
||||
}}}
|
||||
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
[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 <boost/mpl/bool.hpp>
|
||||
#include <utility>
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
template< class T >
|
||||
struct is_pair : public boost::mpl::false_
|
||||
{
|
||||
};
|
||||
|
||||
template< class T1 , class T2 >
|
||||
struct is_pair< std::pair< T1 , T2 > > : public boost::mpl::true_
|
||||
{
|
||||
};
|
||||
|
||||
} // namespace odeint
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_UTIL_IS_PAIR_HPP_INCLUDED
|
||||
@@ -0,0 +1,366 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2014-2014. 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)
|
||||
//
|
||||
// See http://www.boost.org/libs/container for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
|
||||
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
# include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
//In case no decltype and no variadics, mark that we don't support 0 arg calls due to
|
||||
//compiler ICE in GCC 3.4/4.0/4.1 and, wrong SFINAE for GCC 4.2/4.3/MSVC10/MSVC11
|
||||
#if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
# if defined(BOOST_GCC) && (BOOST_GCC < 40400)
|
||||
# define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
|
||||
# elif defined(BOOST_INTEL) && (BOOST_INTEL < 1200)
|
||||
# define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
|
||||
# elif defined(BOOST_MSVC) && (BOOST_MSVC < 1800)
|
||||
# define BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED
|
||||
# endif
|
||||
#endif //#if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
|
||||
#include <cstddef>
|
||||
#include <boost/move/utility_core.hpp>
|
||||
#include <boost/move/detail/fwd_macros.hpp>
|
||||
|
||||
namespace boost_intrusive_hmfcw {
|
||||
|
||||
typedef char yes_type;
|
||||
struct no_type{ char dummy[2]; };
|
||||
|
||||
struct dont_care
|
||||
{
|
||||
dont_care(...);
|
||||
};
|
||||
|
||||
#if defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
|
||||
template<class T>
|
||||
struct make_dontcare
|
||||
{
|
||||
typedef dont_care type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
struct private_type
|
||||
{
|
||||
static private_type p;
|
||||
private_type const &operator,(int) const;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
no_type is_private_type(T const &);
|
||||
yes_type is_private_type(private_type const &);
|
||||
|
||||
#endif //#if defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
template<typename T> struct remove_cv { typedef T type; };
|
||||
template<typename T> struct remove_cv<const T> { typedef T type; };
|
||||
template<typename T> struct remove_cv<const volatile T> { typedef T type; };
|
||||
template<typename T> struct remove_cv<volatile T> { typedef T type; };
|
||||
|
||||
#endif
|
||||
|
||||
} //namespace boost_intrusive_hmfcw {
|
||||
|
||||
#endif //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_CALLABLE_WITH_HPP
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
|
||||
#error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME before including this header!"
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
|
||||
#error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN before including this header!"
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
|
||||
#error "You MUST define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX before including this header!"
|
||||
#endif
|
||||
|
||||
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX < BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
|
||||
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX value MUST be greater or equal than BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN!"
|
||||
#endif
|
||||
|
||||
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX == 0
|
||||
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
|
||||
#else
|
||||
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF ,
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
|
||||
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG not defined!"
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
|
||||
#error "BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END not defined!"
|
||||
#endif
|
||||
|
||||
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
//With decltype and variadic templaes, things are pretty easy
|
||||
template<typename Fun, class ...Args>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
{
|
||||
template<class U>
|
||||
static decltype(boost::move_detail::declval<U>().
|
||||
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...)
|
||||
, boost_intrusive_hmfcw::yes_type()) Test(U* f);
|
||||
template<class U>
|
||||
static boost_intrusive_hmfcw::no_type Test(...);
|
||||
static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
|
||||
};
|
||||
|
||||
#else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////
|
||||
//
|
||||
// has_member_function_callable_with_impl_XXX
|
||||
// declaration, special case and 0 arg specializaton
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
template <typename Type>
|
||||
class BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
{
|
||||
struct BaseMixin
|
||||
{
|
||||
void BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
|
||||
{} //Some compilers require the definition or linker errors happen
|
||||
};
|
||||
|
||||
struct Base
|
||||
: public boost_intrusive_hmfcw::remove_cv<Type>::type, public BaseMixin
|
||||
{ //Declare the unneeded default constructor as some old compilers wrongly require it with is_convertible
|
||||
Base(){}
|
||||
};
|
||||
template <typename T, T t> class Helper{};
|
||||
|
||||
template <typename U>
|
||||
static boost_intrusive_hmfcw::no_type deduce
|
||||
(U*, Helper<void (BaseMixin::*)(), &U::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME>* = 0);
|
||||
static boost_intrusive_hmfcw::yes_type deduce(...);
|
||||
|
||||
public:
|
||||
static const bool value = sizeof(boost_intrusive_hmfcw::yes_type) == sizeof(deduce((Base*)0));
|
||||
};
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
/////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////
|
||||
//
|
||||
// has_member_function_callable_with_impl_XXX for 1 to N arguments
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
//defined(BOOST_NO_CXX11_DECLTYPE) must be true
|
||||
template<class Fun>
|
||||
struct FunWrapTmpl : Fun
|
||||
{
|
||||
using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;
|
||||
FunWrapTmpl();
|
||||
template<class ...DontCares>
|
||||
boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(DontCares...) const;
|
||||
};
|
||||
|
||||
template<typename Fun, bool HasFunc, class ...Args>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME);
|
||||
|
||||
//No BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME member specialization
|
||||
template<typename Fun, class ...Args>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
<Fun, false, Args...>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
template<typename Fun, class ...Args>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true, Args...>
|
||||
{
|
||||
static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) == sizeof(boost_intrusive_hmfcw::is_private_type
|
||||
( (::boost::move_detail::declval
|
||||
< FunWrapTmpl<Fun> >().
|
||||
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(::boost::move_detail::declval<Args>()...), 0) )
|
||||
)
|
||||
);
|
||||
};
|
||||
|
||||
template<typename Fun, class ...Args>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
: public BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
<Fun
|
||||
, BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
|
||||
, Args...>
|
||||
{};
|
||||
#else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////
|
||||
//
|
||||
// has_member_function_callable_with_impl_XXX specializations
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
template<typename Fun, bool HasFunc BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME);
|
||||
|
||||
//No BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME member specialization
|
||||
template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASS,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
<Fun, false BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
|
||||
//0 arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
|
||||
#if !defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
template<typename Fun>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
|
||||
{
|
||||
template<class U>
|
||||
static decltype(boost::move_detail::declval<U>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME()
|
||||
, boost_intrusive_hmfcw::yes_type()) Test(U* f);
|
||||
|
||||
template<class U>
|
||||
static boost_intrusive_hmfcw::no_type Test(...);
|
||||
static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
|
||||
};
|
||||
|
||||
#else //defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
#if !defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
|
||||
|
||||
template<class F, std::size_t N = sizeof(boost::move_detail::declval<F>().BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(), 0)>
|
||||
struct BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
{ boost_intrusive_hmfcw::yes_type dummy[N ? 1 : 2]; };
|
||||
|
||||
template<typename Fun>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
|
||||
{
|
||||
template<class U> static BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>
|
||||
Test(BOOST_MOVE_CAT(zeroarg_checker_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<U>*);
|
||||
template<class U> static boost_intrusive_hmfcw::no_type Test(...);
|
||||
static const bool value = sizeof(Test< Fun >(0)) == sizeof(boost_intrusive_hmfcw::yes_type);
|
||||
};
|
||||
|
||||
#else //defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
|
||||
|
||||
template<typename Fun>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true>
|
||||
{ //Some compilers gives ICE when instantiating the 0 arg version so it is not supported.
|
||||
static const bool value = true;
|
||||
};
|
||||
|
||||
#endif//!defined(BOOST_INTRUSIVE_DETAIL_HAS_MEMBER_FUNCTION_CALLABLE_WITH_0_ARGS_UNSUPPORTED)
|
||||
#endif //!defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
#endif //#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
|
||||
|
||||
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
|
||||
//1 to N arg specialization when BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME is present
|
||||
//Declare some unneeded default constructor as some old compilers wrongly require it with is_convertible
|
||||
#if defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
|
||||
\
|
||||
template<class Fun>\
|
||||
struct BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)\
|
||||
: Fun\
|
||||
{\
|
||||
using Fun::BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME;\
|
||||
BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)();\
|
||||
boost_intrusive_hmfcw::private_type BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME\
|
||||
(BOOST_MOVE_REPEAT##N(boost_intrusive_hmfcw::dont_care)) const;\
|
||||
};\
|
||||
\
|
||||
template<typename Fun, BOOST_MOVE_CLASS##N>\
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun, true, BOOST_MOVE_TARG##N>\
|
||||
{\
|
||||
static bool const value = (sizeof(boost_intrusive_hmfcw::no_type) == sizeof(boost_intrusive_hmfcw::is_private_type\
|
||||
( (::boost::move_detail::declval\
|
||||
< BOOST_MOVE_CAT(FunWrap##N, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun> >().\
|
||||
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N), 0) )\
|
||||
)\
|
||||
);\
|
||||
};\
|
||||
//
|
||||
#else
|
||||
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION(N)\
|
||||
template<typename Fun, BOOST_MOVE_CLASS##N>\
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)\
|
||||
<Fun, true, BOOST_MOVE_TARG##N>\
|
||||
{\
|
||||
template<class U>\
|
||||
static decltype(boost::move_detail::declval<U>().\
|
||||
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME(BOOST_MOVE_DECLVAL##N)\
|
||||
, boost_intrusive_hmfcw::yes_type()) Test(U* f);\
|
||||
template<class U>\
|
||||
static boost_intrusive_hmfcw::no_type Test(...);\
|
||||
static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);\
|
||||
};\
|
||||
//
|
||||
#endif
|
||||
////////////////////////////////////
|
||||
// Build and invoke BOOST_MOVE_ITERATE_NTOM macrofunction, note that N has to be at least 1
|
||||
////////////////////////////////////
|
||||
#if BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN == 0
|
||||
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN 1
|
||||
#else
|
||||
#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
|
||||
#endif
|
||||
BOOST_MOVE_CAT
|
||||
(BOOST_MOVE_CAT(BOOST_MOVE_CAT(BOOST_MOVE_ITERATE_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN), TO)
|
||||
,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)
|
||||
(BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION)
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATION
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_ITERATE_MIN
|
||||
////////////////////////////////////
|
||||
// End of BOOST_MOVE_ITERATE_NTOM
|
||||
////////////////////////////////////
|
||||
#endif //BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX > 0
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////
|
||||
//
|
||||
// has_member_function_callable_with_FUNC
|
||||
//
|
||||
/////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
//Otherwise use the preprocessor
|
||||
template<typename Fun BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_CLASSDFLT,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
|
||||
struct BOOST_MOVE_CAT(has_member_function_callable_with_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
: public BOOST_MOVE_CAT(has_member_function_callable_with_impl_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)
|
||||
<Fun
|
||||
, BOOST_MOVE_CAT(has_member_function_named_, BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME)<Fun>::value
|
||||
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF BOOST_MOVE_CAT(BOOST_MOVE_TARG,BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX)>
|
||||
{};
|
||||
#endif //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
#endif
|
||||
|
||||
BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
|
||||
|
||||
//Undef local macros
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_COMMA_IF
|
||||
|
||||
//Undef user defined macros
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG
|
||||
#undef BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END
|
||||
@@ -0,0 +1,156 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
// Preprocessed version of "boost/mpl/plus.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename Tag1
|
||||
, typename Tag2
|
||||
>
|
||||
struct plus_impl
|
||||
: if_c<
|
||||
( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1)
|
||||
> BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2)
|
||||
)
|
||||
|
||||
, aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 >
|
||||
, aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 >
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
/// for Digital Mars C++/compilers with no CTPS/TTP support
|
||||
template<> struct plus_impl< na,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename Tag > struct plus_impl< na,Tag >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename Tag > struct plus_impl< Tag,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename T > struct plus_tag
|
||||
{
|
||||
typedef typename T::tag type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename BOOST_MPL_AUX_NA_PARAM(N1)
|
||||
, typename BOOST_MPL_AUX_NA_PARAM(N2)
|
||||
, typename N3 = na, typename N4 = na, typename N5 = na
|
||||
>
|
||||
struct plus
|
||||
: plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
5
|
||||
, plus
|
||||
, ( N1, N2, N3, N4, N5 )
|
||||
)
|
||||
};
|
||||
|
||||
template<
|
||||
typename N1, typename N2, typename N3, typename N4
|
||||
>
|
||||
struct plus< N1,N2,N3,N4,na >
|
||||
|
||||
: plus< plus< plus< N1,N2 >, N3>, N4>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
|
||||
5
|
||||
, plus
|
||||
, ( N1, N2, N3, N4, na )
|
||||
)
|
||||
};
|
||||
|
||||
template<
|
||||
typename N1, typename N2, typename N3
|
||||
>
|
||||
struct plus< N1,N2,N3,na,na >
|
||||
|
||||
: plus< plus< N1,N2 >, N3>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
|
||||
5
|
||||
, plus
|
||||
, ( N1, N2, N3, na, na )
|
||||
)
|
||||
};
|
||||
|
||||
template<
|
||||
typename N1, typename N2
|
||||
>
|
||||
struct plus< N1,N2,na,na,na >
|
||||
: plus_impl<
|
||||
typename plus_tag<N1>::type
|
||||
, typename plus_tag<N2>::type
|
||||
>::template apply< N1,N2 >::type
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
|
||||
5
|
||||
, plus
|
||||
, ( N1, N2, na, na, na )
|
||||
)
|
||||
|
||||
};
|
||||
|
||||
BOOST_MPL_AUX_NA_SPEC2(2, 5, plus)
|
||||
|
||||
}}
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
namespace aux {
|
||||
template< typename T, T n1, T n2 >
|
||||
struct plus_wknd
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(T, value = (n1 + n2));
|
||||
typedef integral_c< T,value > type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template<>
|
||||
struct plus_impl< integral_c_tag,integral_c_tag >
|
||||
{
|
||||
template< typename N1, typename N2 > struct apply
|
||||
: aux::plus_wknd<
|
||||
typename aux::largest_int<
|
||||
typename N1::value_type
|
||||
, typename N2::value_type
|
||||
>::type
|
||||
, N1::value
|
||||
, N2::value
|
||||
>::type
|
||||
|
||||
{
|
||||
};
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,9 @@
|
||||
0; 0; 0
|
||||
5; 10; 10
|
||||
22; 42; 42
|
||||
52; 99; 99
|
||||
94;175;175
|
||||
131;209;209
|
||||
162;224;224
|
||||
202;239;239
|
||||
255;255;255
|
||||
@@ -0,0 +1,22 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(FUSION_TRANSFORM_VIEW_FORWARD_01052006_1839)
|
||||
#define FUSION_TRANSFORM_VIEW_FORWARD_01052006_1839
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct void_;
|
||||
struct transform_view_tag;
|
||||
struct transform_view2_tag;
|
||||
|
||||
template <typename A, typename B, typename C = void_>
|
||||
struct transform_view;
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,224 @@
|
||||
// (C) Copyright John Maddock 2007.
|
||||
// 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)
|
||||
//
|
||||
// This file is machine generated, do not edit by hand
|
||||
|
||||
// Polynomial evaluation using second order Horners rule
|
||||
#ifndef BOOST_MATH_TOOLS_RAT_EVAL_15_HPP
|
||||
#define BOOST_MATH_TOOLS_RAT_EVAL_15_HPP
|
||||
|
||||
namespace boost{ namespace math{ namespace tools{ namespace detail{
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T*, const U*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(0);
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(a[0]) / static_cast<V>(b[0]);
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>((a[1] * x + a[0]) / (b[1] * x + b[0]));
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<3>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(((a[2] * x + a[1]) * x + a[0]) / ((b[2] * x + b[1]) * x + b[0]));
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<4>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>((((a[3] * x + a[2]) * x + a[1]) * x + a[0]) / (((b[3] * x + b[2]) * x + b[1]) * x + b[0]));
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<5>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>(((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x) / ((b[4] * x2 + b[2]) * x2 + b[0] + (b[3] * x2 + b[1]) * x));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>(((a[0] * z2 + a[2]) * z2 + a[4] + (a[1] * z2 + a[3]) * z) / ((b[0] * z2 + b[2]) * z2 + b[4] + (b[1] * z2 + b[3]) * z));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<6>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>((((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]) / (((b[5] * x2 + b[3]) * x2 + b[1]) * x + (b[4] * x2 + b[2]) * x2 + b[0]));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>((((a[0] * z2 + a[2]) * z2 + a[4]) * z + (a[1] * z2 + a[3]) * z2 + a[5]) / (((b[0] * z2 + b[2]) * z2 + b[4]) * z + (b[1] * z2 + b[3]) * z2 + b[5]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<7>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>((((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x) / (((b[6] * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + ((b[5] * x2 + b[3]) * x2 + b[1]) * x));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6] + ((a[1] * z2 + a[3]) * z2 + a[5]) * z) / (((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6] + ((b[1] * z2 + b[3]) * z2 + b[5]) * z));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<8>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>(((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]) / ((((b[7] * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x + ((b[6] * x2 + b[4]) * x2 + b[2]) * x2 + b[0]));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>(((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z + ((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) / ((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z + ((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<9>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>(((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x) / ((((b[8] * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + (((b[7] * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>(((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8] + (((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z) / ((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8] + (((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<10>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>((((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]) / (((((b[9] * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x + (((b[8] * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0]));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z + (((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) / (((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z + (((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<11>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>((((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x) / (((((b[10] * x2 + b[8]) * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + ((((b[9] * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z2 + a[10] + ((((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) * z) / (((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z2 + b[10] + ((((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]) * z));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<12>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>(((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]) / ((((((b[11] * x2 + b[9]) * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x + ((((b[10] * x2 + b[8]) * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0]));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>(((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z2 + a[10]) * z + ((((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) * z2 + a[11]) / ((((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z2 + b[10]) * z + ((((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]) * z2 + b[11]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<13>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>(((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x) / ((((((b[12] * x2 + b[10]) * x2 + b[8]) * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + (((((b[11] * x2 + b[9]) * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>(((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z2 + a[10]) * z2 + a[12] + (((((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) * z2 + a[11]) * z) / ((((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z2 + b[10]) * z2 + b[12] + (((((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]) * z2 + b[11]) * z));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<14>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>((((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]) / (((((((b[13] * x2 + b[11]) * x2 + b[9]) * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x + (((((b[12] * x2 + b[10]) * x2 + b[8]) * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0]));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>((((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z2 + a[10]) * z2 + a[12]) * z + (((((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) * z2 + a[11]) * z2 + a[13]) / (((((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z2 + b[10]) * z2 + b[12]) * z + (((((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]) * z2 + b[11]) * z2 + b[13]));
|
||||
}
|
||||
}
|
||||
|
||||
template <class T, class U, class V>
|
||||
inline V evaluate_rational_c_imp(const T* a, const U* b, const V& x, const mpl::int_<15>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
if(x <= 1)
|
||||
{
|
||||
V x2 = x * x;
|
||||
return static_cast<V>((((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x) / (((((((b[14] * x2 + b[12]) * x2 + b[10]) * x2 + b[8]) * x2 + b[6]) * x2 + b[4]) * x2 + b[2]) * x2 + b[0] + ((((((b[13] * x2 + b[11]) * x2 + b[9]) * x2 + b[7]) * x2 + b[5]) * x2 + b[3]) * x2 + b[1]) * x));
|
||||
}
|
||||
else
|
||||
{
|
||||
V z = 1 / x;
|
||||
V z2 = 1 / (x * x);
|
||||
return static_cast<V>((((((((a[0] * z2 + a[2]) * z2 + a[4]) * z2 + a[6]) * z2 + a[8]) * z2 + a[10]) * z2 + a[12]) * z2 + a[14] + ((((((a[1] * z2 + a[3]) * z2 + a[5]) * z2 + a[7]) * z2 + a[9]) * z2 + a[11]) * z2 + a[13]) * z) / (((((((b[0] * z2 + b[2]) * z2 + b[4]) * z2 + b[6]) * z2 + b[8]) * z2 + b[10]) * z2 + b[12]) * z2 + b[14] + ((((((b[1] * z2 + b[3]) * z2 + b[5]) * z2 + b[7]) * z2 + b[9]) * z2 + b[11]) * z2 + b[13]) * z));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}}}} // namespaces
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
/* boost random/uniform_int.hpp header file
|
||||
*
|
||||
* Copyright Jens Maurer 2000-2001
|
||||
* 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)
|
||||
*
|
||||
* See http://www.boost.org for most recent version including documentation.
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Revision history
|
||||
* 2001-04-08 added min<max assertion (N. Becker)
|
||||
* 2001-02-18 moved to individual header files
|
||||
*/
|
||||
|
||||
#ifndef BOOST_RANDOM_UNIFORM_INT_HPP
|
||||
#define BOOST_RANDOM_UNIFORM_INT_HPP
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/random/uniform_int_distribution.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
/**
|
||||
* The distribution function uniform_int models a \random_distribution.
|
||||
* On each invocation, it returns a random integer value uniformly
|
||||
* distributed in the set of integer numbers {min, min+1, min+2, ..., max}.
|
||||
*
|
||||
* The template parameter IntType shall denote an integer-like value type.
|
||||
*
|
||||
* This class is deprecated. Please use @c uniform_int_distribution in
|
||||
* new code.
|
||||
*/
|
||||
template<class IntType = int>
|
||||
class uniform_int : public random::uniform_int_distribution<IntType>
|
||||
{
|
||||
typedef random::uniform_int_distribution<IntType> base_type;
|
||||
public:
|
||||
|
||||
class param_type : public base_type::param_type
|
||||
{
|
||||
public:
|
||||
typedef uniform_int distribution_type;
|
||||
/**
|
||||
* Constructs the parameters of a uniform_int distribution.
|
||||
*
|
||||
* Requires: min <= max
|
||||
*/
|
||||
explicit param_type(IntType min_arg = 0, IntType max_arg = 9)
|
||||
: base_type::param_type(min_arg, max_arg)
|
||||
{}
|
||||
};
|
||||
|
||||
/**
|
||||
* Constructs a uniform_int object. @c min and @c max are
|
||||
* the parameters of the distribution.
|
||||
*
|
||||
* Requires: min <= max
|
||||
*/
|
||||
explicit uniform_int(IntType min_arg = 0, IntType max_arg = 9)
|
||||
: base_type(min_arg, max_arg)
|
||||
{}
|
||||
|
||||
/** Constructs a uniform_int distribution from its parameters. */
|
||||
explicit uniform_int(const param_type& parm)
|
||||
: base_type(parm)
|
||||
{}
|
||||
|
||||
/** Returns the parameters of the distribution */
|
||||
param_type param() const { return param_type(this->a(), this->b()); }
|
||||
/** Sets the parameters of the distribution. */
|
||||
void param(const param_type& parm) { this->base_type::param(parm); }
|
||||
|
||||
// Codergear seems to have trouble with a using declaration here
|
||||
|
||||
template<class Engine>
|
||||
IntType operator()(Engine& eng) const
|
||||
{
|
||||
return static_cast<const base_type&>(*this)(eng);
|
||||
}
|
||||
|
||||
template<class Engine>
|
||||
IntType operator()(Engine& eng, const param_type& parm) const
|
||||
{
|
||||
return static_cast<const base_type&>(*this)(eng, parm);
|
||||
}
|
||||
|
||||
template<class Engine>
|
||||
IntType operator()(Engine& eng, IntType n) const
|
||||
{
|
||||
BOOST_ASSERT(n > 0);
|
||||
return static_cast<const base_type&>(*this)(eng, param_type(0, n - 1));
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_RANDOM_UNIFORM_INT_HPP
|
||||
@@ -0,0 +1,576 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2011 Thomas Heller
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0>
|
||||
struct has_phx2_result<F, A0>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0>
|
||||
struct phx2_result<F, A0>
|
||||
{
|
||||
typedef typename F::template result<A0>::type type;
|
||||
};
|
||||
template <typename F, typename A0>
|
||||
struct phx2_result<F, A0 &>
|
||||
{
|
||||
typedef typename F::template result<A0>::type type;
|
||||
};
|
||||
template <typename F, typename A0>
|
||||
struct phx2_result<F, A0 const&>
|
||||
{
|
||||
typedef typename F::template result<A0>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1>
|
||||
struct has_phx2_result<F, A0 , A1>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1>
|
||||
struct phx2_result<F, A0 , A1>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1>
|
||||
struct phx2_result<F, A0 & , A1 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1>
|
||||
struct phx2_result<F, A0 const& , A1 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2>
|
||||
struct has_phx2_result<F, A0 , A1 , A2>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2>
|
||||
struct phx2_result<F, A0 , A1 , A2>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 & , A16 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const& , A16 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 & , A16 & , A17 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const& , A16 const& , A17 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
|
||||
struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18)> >
|
||||
>::type
|
||||
{};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
|
||||
struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
|
||||
struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 & , A9 & , A10 & , A11 & , A12 & , A13 & , A14 & , A15 & , A16 & , A17 & , A18 &>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>::type type;
|
||||
};
|
||||
template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
|
||||
struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& , A15 const& , A16 const& , A17 const& , A18 const&>
|
||||
{
|
||||
typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18>::type type;
|
||||
};
|
||||
@@ -0,0 +1,54 @@
|
||||
// Copyright 2005 Daniel Wallin.
|
||||
// Copyright 2005 Joel de Guzman.
|
||||
//
|
||||
// Use, modification and distribution is 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)
|
||||
//
|
||||
// Modeled after range_ex, Copyright 2004 Eric Niebler
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// is_std_map.hpp
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_PHOENIX_IS_STD_MAP_EN_16_12_2004
|
||||
#define BOOST_PHOENIX_IS_STD_MAP_EN_16_12_2004
|
||||
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/detail/container_fwd.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template<class T>
|
||||
struct is_std_map
|
||||
: boost::mpl::false_
|
||||
{};
|
||||
|
||||
template<
|
||||
class Kty
|
||||
, class Ty
|
||||
, class Pr
|
||||
, class Alloc
|
||||
>
|
||||
struct is_std_map< ::std::map<Kty,Ty,Pr,Alloc> >
|
||||
: boost::mpl::true_
|
||||
{};
|
||||
|
||||
template<class T>
|
||||
struct is_std_multimap
|
||||
: boost::mpl::false_
|
||||
{};
|
||||
|
||||
template<
|
||||
class Kty
|
||||
, class Ty
|
||||
, class Pr
|
||||
, class Alloc
|
||||
>
|
||||
struct is_std_multimap< ::std::multimap<Kty,Ty,Pr,Alloc> >
|
||||
: boost::mpl::true_
|
||||
{};
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,21 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
==============================================================================*/
|
||||
#if !defined(FUSION_IS_ITERATOR_05062005_1219)
|
||||
#define FUSION_IS_ITERATOR_05062005_1219
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/type_traits/is_base_of.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct iterator_root;
|
||||
|
||||
template <typename T>
|
||||
struct is_fusion_iterator : is_base_of<iterator_root, T> {};
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,126 @@
|
||||
// KISS Interface for posting spots to PSK Reporter web site
|
||||
// Implemented by Edson Pereira PY2SDR
|
||||
//
|
||||
// Reports will be sent in batch mode every 5 minutes.
|
||||
|
||||
#include "psk_reporter.h"
|
||||
|
||||
#include <QHostInfo>
|
||||
#include <QTimer>
|
||||
|
||||
#include "MessageClient.hpp"
|
||||
|
||||
#include "moc_psk_reporter.cpp"
|
||||
|
||||
PSK_Reporter::PSK_Reporter(MessageClient * message_client, QObject *parent) :
|
||||
QObject {parent},
|
||||
m_messageClient {message_client},
|
||||
reportTimer {new QTimer {this}},
|
||||
m_sequenceNumber {0}
|
||||
{
|
||||
m_header_h = "000Allllttttttttssssssssiiiiiiii";
|
||||
|
||||
// We use 50E2 and 50E3 for link Id
|
||||
m_rxInfoDescriptor_h = "0003002C50E200040000"
|
||||
"8002FFFF0000768F" // 2. Rx Call
|
||||
"8004FFFF0000768F" // 4. Rx Grid
|
||||
"8008FFFF0000768F" // 8. Rx Soft
|
||||
"8009FFFF0000768F" // 9. Rx Antenna
|
||||
"0000";
|
||||
|
||||
m_txInfoDescriptor_h = "0002003C50E30007"
|
||||
"8001FFFF0000768F" // 1. Tx Call
|
||||
"800500040000768F" // 5. Tx Freq
|
||||
"800600010000768F" // 6. Tx snr
|
||||
"800AFFFF0000768F" // 10. Tx Mode
|
||||
"8003FFFF0000768F" // 3. Tx Grid
|
||||
"800B00010000768F" // 11. Tx info src
|
||||
"00960004"; // Report time
|
||||
|
||||
|
||||
m_randomId_h = QString("%1").arg(qrand(),8,16,QChar('0'));
|
||||
|
||||
QHostInfo::lookupHost("report.pskreporter.info", this, SLOT(dnsLookupResult(QHostInfo)));
|
||||
|
||||
connect(reportTimer, SIGNAL(timeout()), this, SLOT(sendReport()));
|
||||
reportTimer->start(5*60*1000); // 5 minutes;
|
||||
}
|
||||
|
||||
void PSK_Reporter::setLocalStation(QString call, QString gridSquare, QString antenna, QString programInfo)
|
||||
{
|
||||
m_rxCall = call;
|
||||
m_rxGrid = gridSquare;
|
||||
m_rxAnt = antenna;
|
||||
m_progId = programInfo;
|
||||
}
|
||||
|
||||
void PSK_Reporter::addRemoteStation(QString call, QString grid, QString freq, QString mode, QString snr, QString time )
|
||||
{
|
||||
QHash<QString,QString> spot;
|
||||
spot["call"] = call;
|
||||
spot["grid"] = grid;
|
||||
spot["snr"] = snr;
|
||||
spot["freq"] = freq;
|
||||
spot["mode"] = mode;
|
||||
spot["time"] = time;
|
||||
m_spotQueue.enqueue(spot);
|
||||
}
|
||||
|
||||
void PSK_Reporter::sendReport()
|
||||
{
|
||||
if (m_spotQueue.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
QString report_h;
|
||||
|
||||
// Header
|
||||
QString header_h = m_header_h;
|
||||
header_h.replace("tttttttt", QString("%1").arg(QDateTime::currentDateTime().toTime_t(),8,16,QChar('0')));
|
||||
header_h.replace("ssssssss", QString("%1").arg(++m_sequenceNumber,8,16,QChar('0')));
|
||||
header_h.replace("iiiiiiii", m_randomId_h);
|
||||
|
||||
// Receiver information
|
||||
QString rxInfoData_h = "50E2llll";
|
||||
rxInfoData_h += QString("%1").arg(m_rxCall.length(),2,16,QChar('0')) + m_rxCall.toUtf8().toHex();
|
||||
rxInfoData_h += QString("%1").arg(m_rxGrid.length(),2,16,QChar('0')) + m_rxGrid.toUtf8().toHex();
|
||||
rxInfoData_h += QString("%1").arg(m_progId.length(),2,16,QChar('0')) + m_progId.toUtf8().toHex();
|
||||
rxInfoData_h += QString("%1").arg(m_rxAnt.length(),2,16,QChar('0')) + m_rxAnt.toUtf8().toHex();
|
||||
rxInfoData_h += "0000";
|
||||
rxInfoData_h.replace("50E2llll", "50E2" + QString("%1").arg(rxInfoData_h.length()/2,4,16,QChar('0')));
|
||||
|
||||
// Sender information
|
||||
QString txInfoData_h = "50E3llll";
|
||||
while (!m_spotQueue.isEmpty()) {
|
||||
QHash<QString,QString> spot = m_spotQueue.dequeue();
|
||||
txInfoData_h += QString("%1").arg(spot["call"].length(),2,16,QChar('0')) + spot["call"].toUtf8().toHex();
|
||||
txInfoData_h += QString("%1").arg(spot["freq"].toLongLong(),8,16,QChar('0'));
|
||||
txInfoData_h += QString("%1").arg(spot["snr"].toInt(),8,16,QChar('0')).right(2);
|
||||
txInfoData_h += QString("%1").arg(spot["mode"].length(),2,16,QChar('0')) + spot["mode"].toUtf8().toHex();
|
||||
txInfoData_h += QString("%1").arg(spot["grid"].length(),2,16,QChar('0')) + spot["grid"].toUtf8().toHex();
|
||||
txInfoData_h += QString("%1").arg(1,2,16,QChar('0')); // REPORTER_SOURCE_AUTOMATIC
|
||||
txInfoData_h += QString("%1").arg(spot["time"].toInt(),8,16,QChar('0'));
|
||||
}
|
||||
txInfoData_h += "0000";
|
||||
txInfoData_h.replace("50E3llll", "50E3" + QString("%1").arg(txInfoData_h.length()/2,4,16,QChar('0')));
|
||||
report_h = header_h + m_rxInfoDescriptor_h + m_txInfoDescriptor_h + rxInfoData_h + txInfoData_h;
|
||||
//qDebug() << "Sending Report TX: ";
|
||||
|
||||
report_h.replace("000Allll", "000A" + QString("%1").arg(report_h.length()/2,4,16,QChar('0')));
|
||||
QByteArray report = QByteArray::fromHex(report_h.toUtf8());
|
||||
|
||||
// Send data to PSK Reporter site
|
||||
if (!m_pskReporterAddress.isNull()) {
|
||||
m_messageClient->send_raw_datagram (report, m_pskReporterAddress, 4739);
|
||||
}
|
||||
}
|
||||
|
||||
void PSK_Reporter::dnsLookupResult(QHostInfo info)
|
||||
{
|
||||
if (!info.addresses().isEmpty()) {
|
||||
m_pskReporterAddress = info.addresses().at(0);
|
||||
// qDebug() << "PSK Reporter IP: " << m_pskReporterAddress;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP
|
||||
#define BOOST_SERIALIZATION_SPLIT_FREE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// split_free.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is 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)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/serialization/serialization.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace detail {
|
||||
template<class Archive> class interface_oarchive;
|
||||
template<class Archive> class interface_iarchive;
|
||||
} // namespace detail
|
||||
} // namespace archive
|
||||
|
||||
namespace serialization {
|
||||
|
||||
//namespace detail {
|
||||
template<class Archive, class T>
|
||||
struct free_saver {
|
||||
static void invoke(
|
||||
Archive & ar,
|
||||
const T & t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
// use function overload (version_type) to workaround
|
||||
// two-phase lookup issue
|
||||
const version_type v(file_version);
|
||||
save(ar, t, v);
|
||||
}
|
||||
};
|
||||
template<class Archive, class T>
|
||||
struct free_loader {
|
||||
static void invoke(
|
||||
Archive & ar,
|
||||
T & t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
// use function overload (version_type) to workaround
|
||||
// two-phase lookup issue
|
||||
const version_type v(file_version);
|
||||
load(ar, t, v);
|
||||
}
|
||||
};
|
||||
//} // namespace detail
|
||||
|
||||
template<class Archive, class T>
|
||||
inline void split_free(
|
||||
Archive & ar,
|
||||
T & t,
|
||||
const unsigned int file_version
|
||||
){
|
||||
typedef typename mpl::eval_if<
|
||||
typename Archive::is_saving,
|
||||
mpl::identity</* detail:: */ free_saver<Archive, T> >,
|
||||
mpl::identity</* detail:: */ free_loader<Archive, T> >
|
||||
>::type typex;
|
||||
typex::invoke(ar, t, file_version);
|
||||
}
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
#define BOOST_SERIALIZATION_SPLIT_FREE(T) \
|
||||
namespace boost { namespace serialization { \
|
||||
template<class Archive> \
|
||||
inline void serialize( \
|
||||
Archive & ar, \
|
||||
T & t, \
|
||||
const unsigned int file_version \
|
||||
){ \
|
||||
split_free(ar, t, file_version); \
|
||||
} \
|
||||
}}
|
||||
/**/
|
||||
|
||||
#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP
|
||||
@@ -0,0 +1,331 @@
|
||||
// Boost cerrno.hpp header -------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2005.
|
||||
// Use, modification, and distribution is 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)
|
||||
|
||||
// See library home page at http://www.boost.org/libs/system
|
||||
|
||||
#ifndef BOOST_CERRNO_HPP
|
||||
#define BOOST_CERRNO_HPP
|
||||
|
||||
#include <cerrno>
|
||||
|
||||
// supply errno values likely to be missing, particularly on Windows
|
||||
|
||||
#ifndef EAFNOSUPPORT
|
||||
#define EAFNOSUPPORT 9901
|
||||
#endif
|
||||
|
||||
#ifndef EADDRINUSE
|
||||
#define EADDRINUSE 9902
|
||||
#endif
|
||||
|
||||
#ifndef EADDRNOTAVAIL
|
||||
#define EADDRNOTAVAIL 9903
|
||||
#endif
|
||||
|
||||
#ifndef EISCONN
|
||||
#define EISCONN 9904
|
||||
#endif
|
||||
|
||||
#ifndef EBADMSG
|
||||
#define EBADMSG 9905
|
||||
#endif
|
||||
|
||||
#ifndef ECONNABORTED
|
||||
#define ECONNABORTED 9906
|
||||
#endif
|
||||
|
||||
#ifndef EALREADY
|
||||
#define EALREADY 9907
|
||||
#endif
|
||||
|
||||
#ifndef ECONNREFUSED
|
||||
#define ECONNREFUSED 9908
|
||||
#endif
|
||||
|
||||
#ifndef ECONNRESET
|
||||
#define ECONNRESET 9909
|
||||
#endif
|
||||
|
||||
#ifndef EDESTADDRREQ
|
||||
#define EDESTADDRREQ 9910
|
||||
#endif
|
||||
|
||||
#ifndef EHOSTUNREACH
|
||||
#define EHOSTUNREACH 9911
|
||||
#endif
|
||||
|
||||
#ifndef EIDRM
|
||||
#define EIDRM 9912
|
||||
#endif
|
||||
|
||||
#ifndef EMSGSIZE
|
||||
#define EMSGSIZE 9913
|
||||
#endif
|
||||
|
||||
#ifndef ENETDOWN
|
||||
#define ENETDOWN 9914
|
||||
#endif
|
||||
|
||||
#ifndef ENETRESET
|
||||
#define ENETRESET 9915
|
||||
#endif
|
||||
|
||||
#ifndef ENETUNREACH
|
||||
#define ENETUNREACH 9916
|
||||
#endif
|
||||
|
||||
#ifndef ENOBUFS
|
||||
#define ENOBUFS 9917
|
||||
#endif
|
||||
|
||||
#ifndef ENOLINK
|
||||
#define ENOLINK 9918
|
||||
#endif
|
||||
|
||||
#ifndef ENODATA
|
||||
#define ENODATA 9919
|
||||
#endif
|
||||
|
||||
#ifndef ENOMSG
|
||||
#define ENOMSG 9920
|
||||
#endif
|
||||
|
||||
#ifndef ENOPROTOOPT
|
||||
#define ENOPROTOOPT 9921
|
||||
#endif
|
||||
|
||||
#ifndef ENOSR
|
||||
#define ENOSR 9922
|
||||
#endif
|
||||
|
||||
#ifndef ENOTSOCK
|
||||
#define ENOTSOCK 9923
|
||||
#endif
|
||||
|
||||
#ifndef ENOSTR
|
||||
#define ENOSTR 9924
|
||||
#endif
|
||||
|
||||
#ifndef ENOTCONN
|
||||
#define ENOTCONN 9925
|
||||
#endif
|
||||
|
||||
#ifndef ENOTSUP
|
||||
#define ENOTSUP 9926
|
||||
#endif
|
||||
|
||||
#ifndef ECANCELED
|
||||
#define ECANCELED 9927
|
||||
#endif
|
||||
|
||||
#ifndef EINPROGRESS
|
||||
#define EINPROGRESS 9928
|
||||
#endif
|
||||
|
||||
#ifndef EOPNOTSUPP
|
||||
#define EOPNOTSUPP 9929
|
||||
#endif
|
||||
|
||||
#ifndef EWOULDBLOCK
|
||||
#define EWOULDBLOCK 9930
|
||||
#endif
|
||||
|
||||
#ifndef EOWNERDEAD
|
||||
#define EOWNERDEAD 9931
|
||||
#endif
|
||||
|
||||
#ifndef EPROTO
|
||||
#define EPROTO 9932
|
||||
#endif
|
||||
|
||||
#ifndef EPROTONOSUPPORT
|
||||
#define EPROTONOSUPPORT 9933
|
||||
#endif
|
||||
|
||||
#ifndef ENOTRECOVERABLE
|
||||
#define ENOTRECOVERABLE 9934
|
||||
#endif
|
||||
|
||||
#ifndef ETIME
|
||||
#define ETIME 9935
|
||||
#endif
|
||||
|
||||
#ifndef ETXTBSY
|
||||
#define ETXTBSY 9936
|
||||
#endif
|
||||
|
||||
#ifndef ETIMEDOUT
|
||||
#define ETIMEDOUT 9938
|
||||
#endif
|
||||
|
||||
#ifndef ELOOP
|
||||
#define ELOOP 9939
|
||||
#endif
|
||||
|
||||
#ifndef EOVERFLOW
|
||||
#define EOVERFLOW 9940
|
||||
#endif
|
||||
|
||||
#ifndef EPROTOTYPE
|
||||
#define EPROTOTYPE 9941
|
||||
#endif
|
||||
|
||||
#ifndef ENOSYS
|
||||
#define ENOSYS 9942
|
||||
#endif
|
||||
|
||||
#ifndef EINVAL
|
||||
#define EINVAL 9943
|
||||
#endif
|
||||
|
||||
#ifndef ERANGE
|
||||
#define ERANGE 9944
|
||||
#endif
|
||||
|
||||
#ifndef EILSEQ
|
||||
#define EILSEQ 9945
|
||||
#endif
|
||||
|
||||
// Windows Mobile doesn't appear to define these:
|
||||
|
||||
#ifndef E2BIG
|
||||
#define E2BIG 9946
|
||||
#endif
|
||||
|
||||
#ifndef EDOM
|
||||
#define EDOM 9947
|
||||
#endif
|
||||
|
||||
#ifndef EFAULT
|
||||
#define EFAULT 9948
|
||||
#endif
|
||||
|
||||
#ifndef EBADF
|
||||
#define EBADF 9949
|
||||
#endif
|
||||
|
||||
#ifndef EPIPE
|
||||
#define EPIPE 9950
|
||||
#endif
|
||||
|
||||
#ifndef EXDEV
|
||||
#define EXDEV 9951
|
||||
#endif
|
||||
|
||||
#ifndef EBUSY
|
||||
#define EBUSY 9952
|
||||
#endif
|
||||
|
||||
#ifndef ENOTEMPTY
|
||||
#define ENOTEMPTY 9953
|
||||
#endif
|
||||
|
||||
#ifndef ENOEXEC
|
||||
#define ENOEXEC 9954
|
||||
#endif
|
||||
|
||||
#ifndef EEXIST
|
||||
#define EEXIST 9955
|
||||
#endif
|
||||
|
||||
#ifndef EFBIG
|
||||
#define EFBIG 9956
|
||||
#endif
|
||||
|
||||
#ifndef ENAMETOOLONG
|
||||
#define ENAMETOOLONG 9957
|
||||
#endif
|
||||
|
||||
#ifndef ENOTTY
|
||||
#define ENOTTY 9958
|
||||
#endif
|
||||
|
||||
#ifndef EINTR
|
||||
#define EINTR 9959
|
||||
#endif
|
||||
|
||||
#ifndef ESPIPE
|
||||
#define ESPIPE 9960
|
||||
#endif
|
||||
|
||||
#ifndef EIO
|
||||
#define EIO 9961
|
||||
#endif
|
||||
|
||||
#ifndef EISDIR
|
||||
#define EISDIR 9962
|
||||
#endif
|
||||
|
||||
#ifndef ECHILD
|
||||
#define ECHILD 9963
|
||||
#endif
|
||||
|
||||
#ifndef ENOLCK
|
||||
#define ENOLCK 9964
|
||||
#endif
|
||||
|
||||
#ifndef ENOSPC
|
||||
#define ENOSPC 9965
|
||||
#endif
|
||||
|
||||
#ifndef ENXIO
|
||||
#define ENXIO 9966
|
||||
#endif
|
||||
|
||||
#ifndef ENODEV
|
||||
#define ENODEV 9967
|
||||
#endif
|
||||
|
||||
#ifndef ENOENT
|
||||
#define ENOENT 9968
|
||||
#endif
|
||||
|
||||
#ifndef ESRCH
|
||||
#define ESRCH 9969
|
||||
#endif
|
||||
|
||||
#ifndef ENOTDIR
|
||||
#define ENOTDIR 9970
|
||||
#endif
|
||||
|
||||
#ifndef ENOMEM
|
||||
#define ENOMEM 9971
|
||||
#endif
|
||||
|
||||
#ifndef EPERM
|
||||
#define EPERM 9972
|
||||
#endif
|
||||
|
||||
#ifndef EACCES
|
||||
#define EACCES 9973
|
||||
#endif
|
||||
|
||||
#ifndef EROFS
|
||||
#define EROFS 9974
|
||||
#endif
|
||||
|
||||
#ifndef EDEADLK
|
||||
#define EDEADLK 9975
|
||||
#endif
|
||||
|
||||
#ifndef EAGAIN
|
||||
#define EAGAIN 9976
|
||||
#endif
|
||||
|
||||
#ifndef ENFILE
|
||||
#define ENFILE 9977
|
||||
#endif
|
||||
|
||||
#ifndef EMFILE
|
||||
#define EMFILE 9978
|
||||
#endif
|
||||
|
||||
#ifndef EMLINK
|
||||
#define EMLINK 9979
|
||||
#endif
|
||||
|
||||
#endif // include guard
|
||||
@@ -0,0 +1,40 @@
|
||||
#ifndef WSJTX_CONFIG_H__
|
||||
#define WSJTX_CONFIG_H__
|
||||
|
||||
#define WSJTX_VERSION_MAJOR @WSJTX_VERSION_MAJOR@
|
||||
#define WSJTX_VERSION_MINOR @WSJTX_VERSION_MINOR@
|
||||
#define WSJTX_VERSION_PATCH @WSJTX_VERSION_PATCH@
|
||||
|
||||
#cmakedefine CMAKE_INSTALL_DATAROOTDIR "@CMAKE_INSTALL_DATAROOTDIR@"
|
||||
#cmakedefine CMAKE_INSTALL_DOCDIR "@CMAKE_INSTALL_DOCDIR@"
|
||||
#cmakedefine CMAKE_INSTALL_DATADIR "@CMAKE_INSTALL_DATADIR@"
|
||||
#cmakedefine CMAKE_PROJECT_NAME "@CMAKE_PROJECT_NAME@"
|
||||
#cmakedefine PROJECT_MANUAL "@PROJECT_MANUAL@"
|
||||
#cmakedefine PROJECT_HOMEPAGE "@PROJECT_HOMEPAGE@"
|
||||
#cmakedefine PROJECT_MANUAL_DIRECTORY_URL "@PROJECT_MANUAL_DIRECTORY_URL@"
|
||||
#cmakedefine PROJECT_SAMPLES_URL "@PROJECT_SAMPLES_URL@"
|
||||
|
||||
#cmakedefine01 WSJT_SHARED_RUNTIME
|
||||
#cmakedefine01 WSJT_QDEBUG_TO_FILE
|
||||
#cmakedefine01 WSJT_QDEBUG_IN_RELEASE
|
||||
#cmakedefine01 WSJT_TRACE_CAT
|
||||
#cmakedefine01 WSJT_TRACE_CAT_POLLS
|
||||
#cmakedefine01 WSJT_HAMLIB_TRACE
|
||||
#cmakedefine01 WSJT_HAMLIB_VERBOSE_TRACE
|
||||
#cmakedefine01 WSJT_SOFT_KEYING
|
||||
#cmakedefine01 WSJT_ENABLE_EXPERIMENTAL_FEATURES
|
||||
#cmakedefine01 WSJT_RIG_NONE_CAN_SPLIT
|
||||
|
||||
#define WSJTX_STRINGIZE1(x) #x
|
||||
#define WSJTX_STRINGIZE(x) WSJTX_STRINGIZE1(x)
|
||||
|
||||
/* consistent UNICODE behaviour */
|
||||
#ifndef UNICODE
|
||||
# undef _UNICODE
|
||||
#else
|
||||
# ifndef _UNICODE
|
||||
# define _UNICODE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,21 @@
|
||||
|
||||
#ifndef BOOST_MPL_ALIAS_HPP_INCLUDED
|
||||
#define BOOST_MPL_ALIAS_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// See http://www.boost.org/libs/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
namespace {
|
||||
namespace mpl = boost::mpl;
|
||||
}
|
||||
|
||||
#endif // BOOST_MPL_ALIAS_HPP_INCLUDED
|
||||
@@ -0,0 +1,64 @@
|
||||
// This header intentionally has no include guards.
|
||||
//
|
||||
// Copyright (c) 2001-2009, 2012 Peter Dimov
|
||||
//
|
||||
// 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
|
||||
|
||||
#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )\
|
||||
&& !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
|
||||
|
||||
explicit operator bool () const BOOST_NOEXCEPT
|
||||
{
|
||||
return px != 0;
|
||||
}
|
||||
|
||||
#elif ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
|
||||
|
||||
operator bool () const BOOST_NOEXCEPT
|
||||
{
|
||||
return px != 0;
|
||||
}
|
||||
|
||||
#elif defined( _MANAGED )
|
||||
|
||||
static void unspecified_bool( this_type*** )
|
||||
{
|
||||
}
|
||||
|
||||
typedef void (*unspecified_bool_type)( this_type*** );
|
||||
|
||||
operator unspecified_bool_type() const BOOST_NOEXCEPT
|
||||
{
|
||||
return px == 0? 0: unspecified_bool;
|
||||
}
|
||||
|
||||
#elif \
|
||||
( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
|
||||
( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
|
||||
( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
|
||||
|
||||
typedef element_type * (this_type::*unspecified_bool_type)() const;
|
||||
|
||||
operator unspecified_bool_type() const BOOST_NOEXCEPT
|
||||
{
|
||||
return px == 0? 0: &this_type::get;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
typedef element_type * this_type::*unspecified_bool_type;
|
||||
|
||||
operator unspecified_bool_type() const BOOST_NOEXCEPT
|
||||
{
|
||||
return px == 0? 0: &this_type::px;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
// operator! is redundant, but some compilers need it
|
||||
bool operator! () const BOOST_NOEXCEPT
|
||||
{
|
||||
return px == 0;
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
subroutine genqra64(msg0,ichk,msgsent,itone,itype)
|
||||
|
||||
! Encodes a QRA64 message to yield itone(1:84)
|
||||
|
||||
use packjt
|
||||
character*22 msg0
|
||||
character*22 message !Message to be generated
|
||||
character*22 msgsent !Message as it will be received
|
||||
integer itone(84)
|
||||
character*3 cok !' ' or 'OOO'
|
||||
logical old_qra_sync
|
||||
integer dgen(13)
|
||||
integer sent(63)
|
||||
integer icos7(0:6)
|
||||
data icos7/2,5,6,0,4,1,3/ !Defines a 7x7 Costas array
|
||||
save
|
||||
|
||||
if(msg0(1:1).eq.'@') then
|
||||
read(msg0(2:5),*,end=1,err=1) nfreq
|
||||
go to 2
|
||||
1 nfreq=1000
|
||||
2 itone(1)=nfreq
|
||||
write(msgsent,1000) nfreq
|
||||
1000 format(i5,' Hz')
|
||||
else
|
||||
message=msg0
|
||||
do i=1,22
|
||||
if(ichar(message(i:i)).eq.0) then
|
||||
message(i:)=' '
|
||||
exit
|
||||
endif
|
||||
enddo
|
||||
|
||||
do i=1,22 !Strip leading blanks
|
||||
if(message(1:1).ne.' ') exit
|
||||
message=message(i+1:)
|
||||
enddo
|
||||
|
||||
call chkmsg(message,cok,nspecial,flip)
|
||||
call packmsg(message,dgen,itype) !Pack message into 72 bits
|
||||
call unpackmsg(dgen,msgsent) !Unpack to get message sent
|
||||
if(ichk.ne.0) go to 999 !Return if checking only
|
||||
call qra64_enc(dgen,sent) !Encode using QRA64
|
||||
|
||||
nsync=10
|
||||
inquire(file='old_qra_sync',exist=old_qra_sync)
|
||||
if(old_qra_sync) nsync=1
|
||||
|
||||
itone(1:7)=nsync*icos7 !Insert 7x7 Costas array in 3 places
|
||||
itone(8:39)=sent(1:32)
|
||||
itone(40:46)=nsync*icos7
|
||||
itone(47:77)=sent(33:63)
|
||||
itone(78:84)=nsync*icos7
|
||||
endif
|
||||
|
||||
999 return
|
||||
end subroutine genqra64
|
||||
@@ -0,0 +1,527 @@
|
||||
// boost\math\distributions\poisson.hpp
|
||||
|
||||
// Copyright John Maddock 2006.
|
||||
// Copyright Paul A. Bristow 2007.
|
||||
|
||||
// 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)
|
||||
|
||||
// Poisson distribution is a discrete probability distribution.
|
||||
// It expresses the probability of a number (k) of
|
||||
// events, occurrences, failures or arrivals occurring in a fixed time,
|
||||
// assuming these events occur with a known average or mean rate (lambda)
|
||||
// and are independent of the time since the last event.
|
||||
// The distribution was discovered by Simeon-Denis Poisson (1781-1840).
|
||||
|
||||
// Parameter lambda is the mean number of events in the given time interval.
|
||||
// The random variate k is the number of events, occurrences or arrivals.
|
||||
// k argument may be integral, signed, or unsigned, or floating point.
|
||||
// If necessary, it has already been promoted from an integral type.
|
||||
|
||||
// Note that the Poisson distribution
|
||||
// (like others including the binomial, negative binomial & Bernoulli)
|
||||
// is strictly defined as a discrete function:
|
||||
// only integral values of k are envisaged.
|
||||
// However because the method of calculation uses a continuous gamma function,
|
||||
// it is convenient to treat it as if a continous function,
|
||||
// and permit non-integral values of k.
|
||||
// To enforce the strict mathematical model, users should use floor or ceil functions
|
||||
// on k outside this function to ensure that k is integral.
|
||||
|
||||
// See http://en.wikipedia.org/wiki/Poisson_distribution
|
||||
// http://documents.wolfram.com/v5/Add-onsLinks/StandardPackages/Statistics/DiscreteDistributions.html
|
||||
|
||||
#ifndef BOOST_MATH_SPECIAL_POISSON_HPP
|
||||
#define BOOST_MATH_SPECIAL_POISSON_HPP
|
||||
|
||||
#include <boost/math/distributions/fwd.hpp>
|
||||
#include <boost/math/special_functions/gamma.hpp> // for incomplete gamma. gamma_q
|
||||
#include <boost/math/special_functions/trunc.hpp> // for incomplete gamma. gamma_q
|
||||
#include <boost/math/distributions/complement.hpp> // complements
|
||||
#include <boost/math/distributions/detail/common_error_handling.hpp> // error checks
|
||||
#include <boost/math/special_functions/fpclassify.hpp> // isnan.
|
||||
#include <boost/math/special_functions/factorials.hpp> // factorials.
|
||||
#include <boost/math/tools/roots.hpp> // for root finding.
|
||||
#include <boost/math/distributions/detail/inv_discrete_quantile.hpp>
|
||||
|
||||
#include <utility>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace math
|
||||
{
|
||||
namespace poisson_detail
|
||||
{
|
||||
// Common error checking routines for Poisson distribution functions.
|
||||
// These are convoluted, & apparently redundant, to try to ensure that
|
||||
// checks are always performed, even if exceptions are not enabled.
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline bool check_mean(const char* function, const RealType& mean, RealType* result, const Policy& pol)
|
||||
{
|
||||
if(!(boost::math::isfinite)(mean) || (mean < 0))
|
||||
{
|
||||
*result = policies::raise_domain_error<RealType>(
|
||||
function,
|
||||
"Mean argument is %1%, but must be >= 0 !", mean, pol);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} // bool check_mean
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline bool check_mean_NZ(const char* function, const RealType& mean, RealType* result, const Policy& pol)
|
||||
{ // mean == 0 is considered an error.
|
||||
if( !(boost::math::isfinite)(mean) || (mean <= 0))
|
||||
{
|
||||
*result = policies::raise_domain_error<RealType>(
|
||||
function,
|
||||
"Mean argument is %1%, but must be > 0 !", mean, pol);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} // bool check_mean_NZ
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline bool check_dist(const char* function, const RealType& mean, RealType* result, const Policy& pol)
|
||||
{ // Only one check, so this is redundant really but should be optimized away.
|
||||
return check_mean_NZ(function, mean, result, pol);
|
||||
} // bool check_dist
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline bool check_k(const char* function, const RealType& k, RealType* result, const Policy& pol)
|
||||
{
|
||||
if((k < 0) || !(boost::math::isfinite)(k))
|
||||
{
|
||||
*result = policies::raise_domain_error<RealType>(
|
||||
function,
|
||||
"Number of events k argument is %1%, but must be >= 0 !", k, pol);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} // bool check_k
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline bool check_dist_and_k(const char* function, RealType mean, RealType k, RealType* result, const Policy& pol)
|
||||
{
|
||||
if((check_dist(function, mean, result, pol) == false) ||
|
||||
(check_k(function, k, result, pol) == false))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} // bool check_dist_and_k
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline bool check_prob(const char* function, const RealType& p, RealType* result, const Policy& pol)
|
||||
{ // Check 0 <= p <= 1
|
||||
if(!(boost::math::isfinite)(p) || (p < 0) || (p > 1))
|
||||
{
|
||||
*result = policies::raise_domain_error<RealType>(
|
||||
function,
|
||||
"Probability argument is %1%, but must be >= 0 and <= 1 !", p, pol);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} // bool check_prob
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline bool check_dist_and_prob(const char* function, RealType mean, RealType p, RealType* result, const Policy& pol)
|
||||
{
|
||||
if((check_dist(function, mean, result, pol) == false) ||
|
||||
(check_prob(function, p, result, pol) == false))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} // bool check_dist_and_prob
|
||||
|
||||
} // namespace poisson_detail
|
||||
|
||||
template <class RealType = double, class Policy = policies::policy<> >
|
||||
class poisson_distribution
|
||||
{
|
||||
public:
|
||||
typedef RealType value_type;
|
||||
typedef Policy policy_type;
|
||||
|
||||
poisson_distribution(RealType l_mean = 1) : m_l(l_mean) // mean (lambda).
|
||||
{ // Expected mean number of events that occur during the given interval.
|
||||
RealType r;
|
||||
poisson_detail::check_dist(
|
||||
"boost::math::poisson_distribution<%1%>::poisson_distribution",
|
||||
m_l,
|
||||
&r, Policy());
|
||||
} // poisson_distribution constructor.
|
||||
|
||||
RealType mean() const
|
||||
{ // Private data getter function.
|
||||
return m_l;
|
||||
}
|
||||
private:
|
||||
// Data member, initialized by constructor.
|
||||
RealType m_l; // mean number of occurrences.
|
||||
}; // template <class RealType, class Policy> class poisson_distribution
|
||||
|
||||
typedef poisson_distribution<double> poisson; // Reserved name of type double.
|
||||
|
||||
// Non-member functions to give properties of the distribution.
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline const std::pair<RealType, RealType> range(const poisson_distribution<RealType, Policy>& /* dist */)
|
||||
{ // Range of permissible values for random variable k.
|
||||
using boost::math::tools::max_value;
|
||||
return std::pair<RealType, RealType>(static_cast<RealType>(0), max_value<RealType>()); // Max integer?
|
||||
}
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline const std::pair<RealType, RealType> support(const poisson_distribution<RealType, Policy>& /* dist */)
|
||||
{ // Range of supported values for random variable k.
|
||||
// This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
|
||||
using boost::math::tools::max_value;
|
||||
return std::pair<RealType, RealType>(static_cast<RealType>(0), max_value<RealType>());
|
||||
}
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType mean(const poisson_distribution<RealType, Policy>& dist)
|
||||
{ // Mean of poisson distribution = lambda.
|
||||
return dist.mean();
|
||||
} // mean
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType mode(const poisson_distribution<RealType, Policy>& dist)
|
||||
{ // mode.
|
||||
BOOST_MATH_STD_USING // ADL of std functions.
|
||||
return floor(dist.mean());
|
||||
}
|
||||
|
||||
//template <class RealType, class Policy>
|
||||
//inline RealType median(const poisson_distribution<RealType, Policy>& dist)
|
||||
//{ // median = approximately lambda + 1/3 - 0.2/lambda
|
||||
// RealType l = dist.mean();
|
||||
// return dist.mean() + static_cast<RealType>(0.3333333333333333333333333333333333333333333333)
|
||||
// - static_cast<RealType>(0.2) / l;
|
||||
//} // BUT this formula appears to be out-by-one compared to quantile(half)
|
||||
// Query posted on Wikipedia.
|
||||
// Now implemented via quantile(half) in derived accessors.
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType variance(const poisson_distribution<RealType, Policy>& dist)
|
||||
{ // variance.
|
||||
return dist.mean();
|
||||
}
|
||||
|
||||
// RealType standard_deviation(const poisson_distribution<RealType, Policy>& dist)
|
||||
// standard_deviation provided by derived accessors.
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType skewness(const poisson_distribution<RealType, Policy>& dist)
|
||||
{ // skewness = sqrt(l).
|
||||
BOOST_MATH_STD_USING // ADL of std functions.
|
||||
return 1 / sqrt(dist.mean());
|
||||
}
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType kurtosis_excess(const poisson_distribution<RealType, Policy>& dist)
|
||||
{ // skewness = sqrt(l).
|
||||
return 1 / dist.mean(); // kurtosis_excess 1/mean from Wiki & MathWorld eq 31.
|
||||
// http://mathworld.wolfram.com/Kurtosis.html explains that the kurtosis excess
|
||||
// is more convenient because the kurtosis excess of a normal distribution is zero
|
||||
// whereas the true kurtosis is 3.
|
||||
} // RealType kurtosis_excess
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType kurtosis(const poisson_distribution<RealType, Policy>& dist)
|
||||
{ // kurtosis is 4th moment about the mean = u4 / sd ^ 4
|
||||
// http://en.wikipedia.org/wiki/Curtosis
|
||||
// kurtosis can range from -2 (flat top) to +infinity (sharp peak & heavy tails).
|
||||
// http://www.itl.nist.gov/div898/handbook/eda/section3/eda35b.htm
|
||||
return 3 + 1 / dist.mean(); // NIST.
|
||||
// http://mathworld.wolfram.com/Kurtosis.html explains that the kurtosis excess
|
||||
// is more convenient because the kurtosis excess of a normal distribution is zero
|
||||
// whereas the true kurtosis is 3.
|
||||
} // RealType kurtosis
|
||||
|
||||
template <class RealType, class Policy>
|
||||
RealType pdf(const poisson_distribution<RealType, Policy>& dist, const RealType& k)
|
||||
{ // Probability Density/Mass Function.
|
||||
// Probability that there are EXACTLY k occurrences (or arrivals).
|
||||
BOOST_FPU_EXCEPTION_GUARD
|
||||
|
||||
BOOST_MATH_STD_USING // for ADL of std functions.
|
||||
|
||||
RealType mean = dist.mean();
|
||||
// Error check:
|
||||
RealType result = 0;
|
||||
if(false == poisson_detail::check_dist_and_k(
|
||||
"boost::math::pdf(const poisson_distribution<%1%>&, %1%)",
|
||||
mean,
|
||||
k,
|
||||
&result, Policy()))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
// Special case of mean zero, regardless of the number of events k.
|
||||
if (mean == 0)
|
||||
{ // Probability for any k is zero.
|
||||
return 0;
|
||||
}
|
||||
if (k == 0)
|
||||
{ // mean ^ k = 1, and k! = 1, so can simplify.
|
||||
return exp(-mean);
|
||||
}
|
||||
return boost::math::gamma_p_derivative(k+1, mean, Policy());
|
||||
} // pdf
|
||||
|
||||
template <class RealType, class Policy>
|
||||
RealType cdf(const poisson_distribution<RealType, Policy>& dist, const RealType& k)
|
||||
{ // Cumulative Distribution Function Poisson.
|
||||
// The random variate k is the number of occurrences(or arrivals)
|
||||
// k argument may be integral, signed, or unsigned, or floating point.
|
||||
// If necessary, it has already been promoted from an integral type.
|
||||
// Returns the sum of the terms 0 through k of the Poisson Probability Density or Mass (pdf).
|
||||
|
||||
// But note that the Poisson distribution
|
||||
// (like others including the binomial, negative binomial & Bernoulli)
|
||||
// is strictly defined as a discrete function: only integral values of k are envisaged.
|
||||
// However because of the method of calculation using a continuous gamma function,
|
||||
// it is convenient to treat it as if it is a continous function
|
||||
// and permit non-integral values of k.
|
||||
// To enforce the strict mathematical model, users should use floor or ceil functions
|
||||
// outside this function to ensure that k is integral.
|
||||
|
||||
// The terms are not summed directly (at least for larger k)
|
||||
// instead the incomplete gamma integral is employed,
|
||||
|
||||
BOOST_MATH_STD_USING // for ADL of std function exp.
|
||||
|
||||
RealType mean = dist.mean();
|
||||
// Error checks:
|
||||
RealType result = 0;
|
||||
if(false == poisson_detail::check_dist_and_k(
|
||||
"boost::math::cdf(const poisson_distribution<%1%>&, %1%)",
|
||||
mean,
|
||||
k,
|
||||
&result, Policy()))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
// Special cases:
|
||||
if (mean == 0)
|
||||
{ // Probability for any k is zero.
|
||||
return 0;
|
||||
}
|
||||
if (k == 0)
|
||||
{ // return pdf(dist, static_cast<RealType>(0));
|
||||
// but mean (and k) have already been checked,
|
||||
// so this avoids unnecessary repeated checks.
|
||||
return exp(-mean);
|
||||
}
|
||||
// For small integral k could use a finite sum -
|
||||
// it's cheaper than the gamma function.
|
||||
// BUT this is now done efficiently by gamma_q function.
|
||||
// Calculate poisson cdf using the gamma_q function.
|
||||
return gamma_q(k+1, mean, Policy());
|
||||
} // binomial cdf
|
||||
|
||||
template <class RealType, class Policy>
|
||||
RealType cdf(const complemented2_type<poisson_distribution<RealType, Policy>, RealType>& c)
|
||||
{ // Complemented Cumulative Distribution Function Poisson
|
||||
// The random variate k is the number of events, occurrences or arrivals.
|
||||
// k argument may be integral, signed, or unsigned, or floating point.
|
||||
// If necessary, it has already been promoted from an integral type.
|
||||
// But note that the Poisson distribution
|
||||
// (like others including the binomial, negative binomial & Bernoulli)
|
||||
// is strictly defined as a discrete function: only integral values of k are envisaged.
|
||||
// However because of the method of calculation using a continuous gamma function,
|
||||
// it is convenient to treat it as is it is a continous function
|
||||
// and permit non-integral values of k.
|
||||
// To enforce the strict mathematical model, users should use floor or ceil functions
|
||||
// outside this function to ensure that k is integral.
|
||||
|
||||
// Returns the sum of the terms k+1 through inf of the Poisson Probability Density/Mass (pdf).
|
||||
// The terms are not summed directly (at least for larger k)
|
||||
// instead the incomplete gamma integral is employed,
|
||||
|
||||
RealType const& k = c.param;
|
||||
poisson_distribution<RealType, Policy> const& dist = c.dist;
|
||||
|
||||
RealType mean = dist.mean();
|
||||
|
||||
// Error checks:
|
||||
RealType result = 0;
|
||||
if(false == poisson_detail::check_dist_and_k(
|
||||
"boost::math::cdf(const poisson_distribution<%1%>&, %1%)",
|
||||
mean,
|
||||
k,
|
||||
&result, Policy()))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
// Special case of mean, regardless of the number of events k.
|
||||
if (mean == 0)
|
||||
{ // Probability for any k is unity, complement of zero.
|
||||
return 1;
|
||||
}
|
||||
if (k == 0)
|
||||
{ // Avoid repeated checks on k and mean in gamma_p.
|
||||
return -boost::math::expm1(-mean, Policy());
|
||||
}
|
||||
// Unlike un-complemented cdf (sum from 0 to k),
|
||||
// can't use finite sum from k+1 to infinity for small integral k,
|
||||
// anyway it is now done efficiently by gamma_p.
|
||||
return gamma_p(k + 1, mean, Policy()); // Calculate Poisson cdf using the gamma_p function.
|
||||
// CCDF = gamma_p(k+1, lambda)
|
||||
} // poisson ccdf
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType quantile(const poisson_distribution<RealType, Policy>& dist, const RealType& p)
|
||||
{ // Quantile (or Percent Point) Poisson function.
|
||||
// Return the number of expected events k for a given probability p.
|
||||
static const char* function = "boost::math::quantile(const poisson_distribution<%1%>&, %1%)";
|
||||
RealType result = 0; // of Argument checks:
|
||||
if(false == poisson_detail::check_prob(
|
||||
function,
|
||||
p,
|
||||
&result, Policy()))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
// Special case:
|
||||
if (dist.mean() == 0)
|
||||
{ // if mean = 0 then p = 0, so k can be anything?
|
||||
if (false == poisson_detail::check_mean_NZ(
|
||||
function,
|
||||
dist.mean(),
|
||||
&result, Policy()))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
if(p == 0)
|
||||
{
|
||||
return 0; // Exact result regardless of discrete-quantile Policy
|
||||
}
|
||||
if(p == 1)
|
||||
{
|
||||
return policies::raise_overflow_error<RealType>(function, 0, Policy());
|
||||
}
|
||||
typedef typename Policy::discrete_quantile_type discrete_type;
|
||||
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
|
||||
RealType guess, factor = 8;
|
||||
RealType z = dist.mean();
|
||||
if(z < 1)
|
||||
guess = z;
|
||||
else
|
||||
guess = boost::math::detail::inverse_poisson_cornish_fisher(z, p, RealType(1-p), Policy());
|
||||
if(z > 5)
|
||||
{
|
||||
if(z > 1000)
|
||||
factor = 1.01f;
|
||||
else if(z > 50)
|
||||
factor = 1.1f;
|
||||
else if(guess > 10)
|
||||
factor = 1.25f;
|
||||
else
|
||||
factor = 2;
|
||||
if(guess < 1.1)
|
||||
factor = 8;
|
||||
}
|
||||
|
||||
return detail::inverse_discrete_quantile(
|
||||
dist,
|
||||
p,
|
||||
false,
|
||||
guess,
|
||||
factor,
|
||||
RealType(1),
|
||||
discrete_type(),
|
||||
max_iter);
|
||||
} // quantile
|
||||
|
||||
template <class RealType, class Policy>
|
||||
inline RealType quantile(const complemented2_type<poisson_distribution<RealType, Policy>, RealType>& c)
|
||||
{ // Quantile (or Percent Point) of Poisson function.
|
||||
// Return the number of expected events k for a given
|
||||
// complement of the probability q.
|
||||
//
|
||||
// Error checks:
|
||||
static const char* function = "boost::math::quantile(complement(const poisson_distribution<%1%>&, %1%))";
|
||||
RealType q = c.param;
|
||||
const poisson_distribution<RealType, Policy>& dist = c.dist;
|
||||
RealType result = 0; // of argument checks.
|
||||
if(false == poisson_detail::check_prob(
|
||||
function,
|
||||
q,
|
||||
&result, Policy()))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
// Special case:
|
||||
if (dist.mean() == 0)
|
||||
{ // if mean = 0 then p = 0, so k can be anything?
|
||||
if (false == poisson_detail::check_mean_NZ(
|
||||
function,
|
||||
dist.mean(),
|
||||
&result, Policy()))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
if(q == 0)
|
||||
{
|
||||
return policies::raise_overflow_error<RealType>(function, 0, Policy());
|
||||
}
|
||||
if(q == 1)
|
||||
{
|
||||
return 0; // Exact result regardless of discrete-quantile Policy
|
||||
}
|
||||
typedef typename Policy::discrete_quantile_type discrete_type;
|
||||
boost::uintmax_t max_iter = policies::get_max_root_iterations<Policy>();
|
||||
RealType guess, factor = 8;
|
||||
RealType z = dist.mean();
|
||||
if(z < 1)
|
||||
guess = z;
|
||||
else
|
||||
guess = boost::math::detail::inverse_poisson_cornish_fisher(z, RealType(1-q), q, Policy());
|
||||
if(z > 5)
|
||||
{
|
||||
if(z > 1000)
|
||||
factor = 1.01f;
|
||||
else if(z > 50)
|
||||
factor = 1.1f;
|
||||
else if(guess > 10)
|
||||
factor = 1.25f;
|
||||
else
|
||||
factor = 2;
|
||||
if(guess < 1.1)
|
||||
factor = 8;
|
||||
}
|
||||
|
||||
return detail::inverse_discrete_quantile(
|
||||
dist,
|
||||
q,
|
||||
true,
|
||||
guess,
|
||||
factor,
|
||||
RealType(1),
|
||||
discrete_type(),
|
||||
max_iter);
|
||||
} // quantile complement.
|
||||
|
||||
} // namespace math
|
||||
} // namespace boost
|
||||
|
||||
// This include must be at the end, *after* the accessors
|
||||
// for this distribution have been defined, in order to
|
||||
// keep compilers that support two-phase lookup happy.
|
||||
#include <boost/math/distributions/detail/derived_accessors.hpp>
|
||||
#include <boost/math/distributions/detail/inv_discrete_quantile.hpp>
|
||||
|
||||
#endif // BOOST_MATH_SPECIAL_POISSON_HPP
|
||||
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user