Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,254 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2003 Joel de Guzman
|
||||
Copyright (c) 2002-2003 Hartmut Kaiser
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
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_SPIRIT_PARSER_NAMES_HPP)
|
||||
#define BOOST_SPIRIT_PARSER_NAMES_HPP
|
||||
|
||||
#if defined(BOOST_SPIRIT_DEBUG)
|
||||
|
||||
//////////////////////////////////
|
||||
#include <boost/spirit/home/classic/namespace.hpp>
|
||||
#include <boost/spirit/home/classic/core.hpp>
|
||||
|
||||
namespace boost { namespace spirit {
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Declaration of helper functions, which return the name of a concrete
|
||||
// parser instance. The functions are specialized on the parser types. The
|
||||
// functions declared in this file are for the predefined parser types from
|
||||
// the Spirit core library only, so additional functions might be provided as
|
||||
// needed.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from actions.hpp
|
||||
template <typename ParserT, typename ActionT>
|
||||
std::string
|
||||
parser_name(action<ParserT, ActionT> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from directives.hpp
|
||||
template <typename ParserT>
|
||||
std::string
|
||||
parser_name(contiguous<ParserT> const& p);
|
||||
|
||||
template <typename ParserT>
|
||||
std::string
|
||||
parser_name(inhibit_case<ParserT> const& p);
|
||||
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(longest_alternative<A, B> const& p);
|
||||
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(shortest_alternative<A, B> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from grammar.hpp
|
||||
template <typename DerivedT, typename ContextT>
|
||||
std::string
|
||||
parser_name(grammar<DerivedT, ContextT> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from numerics.hpp
|
||||
template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
|
||||
std::string
|
||||
parser_name(uint_parser<T, Radix, MinDigits, MaxDigits> const& p);
|
||||
|
||||
template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
|
||||
std::string
|
||||
parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& p);
|
||||
|
||||
template <typename T, typename RealPoliciesT>
|
||||
std::string
|
||||
parser_name(real_parser<T, RealPoliciesT> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from operators.hpp
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(sequence<A, B> const& p);
|
||||
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(sequential_or<A, B> const& p);
|
||||
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(alternative<A, B> const& p);
|
||||
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(intersection<A, B> const& p);
|
||||
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(difference<A, B> const& p);
|
||||
|
||||
template <typename A, typename B>
|
||||
std::string
|
||||
parser_name(exclusive_or<A, B> const& p);
|
||||
|
||||
template <typename S>
|
||||
std::string
|
||||
parser_name(optional<S> const& p);
|
||||
|
||||
template <typename S>
|
||||
std::string
|
||||
parser_name(kleene_star<S> const& p);
|
||||
|
||||
template <typename S>
|
||||
std::string
|
||||
parser_name(positive<S> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from parser.hpp
|
||||
template <typename DerivedT>
|
||||
std::string
|
||||
parser_name(parser<DerivedT> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from primitives.hpp
|
||||
template <typename DerivedT>
|
||||
std::string
|
||||
parser_name(char_parser<DerivedT> const &p);
|
||||
|
||||
template <typename CharT>
|
||||
std::string
|
||||
parser_name(chlit<CharT> const &p);
|
||||
|
||||
template <typename CharT>
|
||||
std::string
|
||||
parser_name(range<CharT> const &p);
|
||||
|
||||
template <typename IteratorT>
|
||||
std::string
|
||||
parser_name(chseq<IteratorT> const &p);
|
||||
|
||||
template <typename IteratorT>
|
||||
std::string
|
||||
parser_name(strlit<IteratorT> const &p);
|
||||
|
||||
std::string
|
||||
parser_name(nothing_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(epsilon_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(anychar_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(alnum_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(alpha_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(cntrl_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(digit_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(graph_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(lower_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(print_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(punct_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(blank_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(space_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(upper_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(xdigit_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(eol_parser const &p);
|
||||
|
||||
std::string
|
||||
parser_name(end_parser const &p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from rule.hpp
|
||||
template<typename T0, typename T1, typename T2>
|
||||
std::string
|
||||
parser_name(rule<T0, T1, T2> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from subrule.hpp
|
||||
template <typename FirstT, typename RestT>
|
||||
std::string
|
||||
parser_name(subrule_list<FirstT, RestT> const &p);
|
||||
|
||||
template <int ID, typename DefT, typename ContextT>
|
||||
std::string
|
||||
parser_name(subrule_parser<ID, DefT, ContextT> const &p);
|
||||
|
||||
template <int ID, typename ContextT>
|
||||
std::string
|
||||
parser_name(subrule<ID, ContextT> const &p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// from chset.hpp
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Decide, if a node is to be traced or not
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template<
|
||||
typename DerivedT, typename EmbedT,
|
||||
typename T0, typename T1, typename T2
|
||||
>
|
||||
bool
|
||||
trace_parser(impl::rule_base<DerivedT, EmbedT, T0, T1, T2>
|
||||
const& p);
|
||||
|
||||
template <typename DerivedT, typename ContextT>
|
||||
bool
|
||||
trace_parser(grammar<DerivedT, ContextT> const& p);
|
||||
|
||||
template <int ID, typename ContextT>
|
||||
bool
|
||||
trace_parser(subrule<ID, ContextT> const& p);
|
||||
|
||||
template <typename ParserT, typename ActorTupleT>
|
||||
struct init_closure_parser;
|
||||
|
||||
template <typename ParserT, typename ActorTupleT>
|
||||
bool
|
||||
trace_parser(init_closure_parser<ParserT, ActorTupleT> const& p);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}} // namespace BOOST_SPIRIT_CLASSIC_NS
|
||||
|
||||
//////////////////////////////////
|
||||
#include <boost/spirit/home/classic/debug/impl/parser_names.ipp>
|
||||
|
||||
#endif // defined(BOOST_SPIRIT_DEBUG)
|
||||
|
||||
#endif // !defined(BOOST_SPIRIT_PARSER_NAMES_HPP)
|
||||
@@ -0,0 +1,63 @@
|
||||
subroutine demod64a(s3,nadd,afac1,mrsym,mrprob,mr2sym,mr2prob,ntest,nlow)
|
||||
|
||||
! Demodulate the 64-bin spectra for each of 63 symbols in a frame.
|
||||
|
||||
! Parameters
|
||||
! nadd number of spectra already summed
|
||||
! mrsym most reliable symbol value
|
||||
! mr2sym second most likely symbol value
|
||||
! mrprob probability that mrsym was the transmitted value
|
||||
! mr2prob probability that mr2sym was the transmitted value
|
||||
|
||||
implicit real*8 (a-h,o-z)
|
||||
real*4 s3(64,63),afac1
|
||||
real*8 fs(64)
|
||||
integer mrsym(63),mrprob(63),mr2sym(63),mr2prob(63)
|
||||
|
||||
if(nadd.eq.-999) return
|
||||
afac=afac1 * float(nadd)**0.64
|
||||
scale=255.999
|
||||
|
||||
! Compute average spectral value
|
||||
ave=sum(s3)/(64.*63.)
|
||||
i1=1 !Silence warning
|
||||
i2=1
|
||||
|
||||
! Compute probabilities for most reliable symbol values
|
||||
do j=1,63
|
||||
s1=-1.e30
|
||||
psum=0.
|
||||
do i=1,64
|
||||
x=min(afac*s3(i,j)/ave,50.d0)
|
||||
fs(i)=exp(x)
|
||||
psum=psum+s3(i,j)
|
||||
if(s3(i,j).gt.s1) then
|
||||
s1=s3(i,j)
|
||||
i1=i !Most reliable
|
||||
endif
|
||||
enddo
|
||||
if(psum.eq.0.0) psum=1.e-6
|
||||
|
||||
s2=-1.e30
|
||||
do i=1,64
|
||||
if(i.ne.i1 .and. s3(i,j).gt.s2) then
|
||||
s2=s3(i,j)
|
||||
i2=i !Second most reliable
|
||||
endif
|
||||
enddo
|
||||
p1=s1/psum !Symbol metrics for ftrsd
|
||||
p2=s2/psum
|
||||
mrsym(j)=i1-1
|
||||
mr2sym(j)=i2-1
|
||||
mrprob(j)=scale*p1
|
||||
mr2prob(j)=scale*p2
|
||||
enddo
|
||||
|
||||
nlow=0
|
||||
do j=1,63
|
||||
if(mrprob(j).le.5) nlow=nlow+1
|
||||
enddo
|
||||
ntest=sum(mrprob)
|
||||
|
||||
return
|
||||
end subroutine demod64a
|
||||
Binary file not shown.
@@ -0,0 +1,44 @@
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
|
||||
//
|
||||
// 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://boostorg.github.com/compute for more information.
|
||||
//---------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_COMPUTE_DETAIL_ITERATOR_RANGE_SIZE_H
|
||||
#define BOOST_COMPUTE_DETAIL_ITERATOR_RANGE_SIZE_H
|
||||
|
||||
#include <cstddef>
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
|
||||
namespace boost {
|
||||
namespace compute {
|
||||
namespace detail {
|
||||
|
||||
// This is a convenience function which returns the size of a range
|
||||
// bounded by two iterators. This function has two differences from
|
||||
// the std::distance() function: 1) the return type (size_t) is
|
||||
// unsigned, and 2) the return value is always positive.
|
||||
template<class Iterator>
|
||||
inline size_t iterator_range_size(Iterator first, Iterator last)
|
||||
{
|
||||
typedef typename
|
||||
std::iterator_traits<Iterator>::difference_type
|
||||
difference_type;
|
||||
|
||||
difference_type difference = std::distance(first, last);
|
||||
|
||||
return static_cast<size_t>(
|
||||
(std::max)(difference, static_cast<difference_type>(0))
|
||||
);
|
||||
}
|
||||
|
||||
} // end detail namespace
|
||||
} // end compute namespace
|
||||
} // end boost namespace
|
||||
|
||||
#endif // BOOST_COMPUTE_DETAIL_ITERATOR_RANGE_SIZE_H
|
||||
@@ -0,0 +1,147 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
// Copyright Jaap Suter 2003
|
||||
//
|
||||
// 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/bitand.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename Tag1
|
||||
, typename Tag2
|
||||
>
|
||||
struct bitand_impl
|
||||
: if_c<
|
||||
( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1)
|
||||
> BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2)
|
||||
)
|
||||
|
||||
, aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 >
|
||||
, aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 >
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
/// for Digital Mars C++/compilers with no CTPS/TTP support
|
||||
template<> struct bitand_impl< na,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename Tag > struct bitand_impl< na,Tag >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename Tag > struct bitand_impl< Tag,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename T > struct bitand_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 bitand_
|
||||
: bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
5
|
||||
, bitand_
|
||||
, ( N1, N2, N3, N4, N5 )
|
||||
)
|
||||
};
|
||||
|
||||
template<
|
||||
typename N1, typename N2, typename N3, typename N4
|
||||
>
|
||||
struct bitand_< N1,N2,N3,N4,na >
|
||||
|
||||
: bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
|
||||
5
|
||||
, bitand_
|
||||
, ( N1, N2, N3, N4, na )
|
||||
)
|
||||
};
|
||||
|
||||
template<
|
||||
typename N1, typename N2, typename N3
|
||||
>
|
||||
struct bitand_< N1,N2,N3,na,na >
|
||||
|
||||
: bitand_< bitand_< N1,N2 >, N3>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
|
||||
5
|
||||
, bitand_
|
||||
, ( N1, N2, N3, na, na )
|
||||
)
|
||||
};
|
||||
|
||||
template<
|
||||
typename N1, typename N2
|
||||
>
|
||||
struct bitand_< N1,N2,na,na,na >
|
||||
: bitand_impl<
|
||||
typename bitand_tag<N1>::type
|
||||
, typename bitand_tag<N2>::type
|
||||
>::template apply< N1,N2 >::type
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(
|
||||
5
|
||||
, bitand_
|
||||
, ( N1, N2, na, na, na )
|
||||
)
|
||||
|
||||
};
|
||||
|
||||
BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_)
|
||||
|
||||
}}
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
template<>
|
||||
struct bitand_impl< integral_c_tag,integral_c_tag >
|
||||
{
|
||||
template< typename N1, typename N2 > struct apply
|
||||
|
||||
: integral_c<
|
||||
typename aux::largest_int<
|
||||
typename N1::value_type
|
||||
, typename N2::value_type
|
||||
>::type
|
||||
, ( BOOST_MPL_AUX_VALUE_WKND(N1)::value
|
||||
& BOOST_MPL_AUX_VALUE_WKND(N2)::value
|
||||
)
|
||||
>
|
||||
{
|
||||
};
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,209 @@
|
||||
/* boost random/chi_squared_distribution.hpp header file
|
||||
*
|
||||
* Copyright Steven Watanabe 2011
|
||||
* 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$
|
||||
*/
|
||||
|
||||
#ifndef BOOST_RANDOM_CHI_SQUARED_DISTRIBUTION_HPP_INCLUDED
|
||||
#define BOOST_RANDOM_CHI_SQUARED_DISTRIBUTION_HPP_INCLUDED
|
||||
|
||||
#include <iosfwd>
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
#include <boost/random/detail/config.hpp>
|
||||
#include <boost/random/gamma_distribution.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace random {
|
||||
|
||||
/**
|
||||
* The chi squared distribution is a real valued distribution with
|
||||
* one parameter, @c n. The distribution produces values > 0.
|
||||
*
|
||||
* The distribution function is
|
||||
* \f$\displaystyle P(x) = \frac{x^{(n/2)-1}e^{-x/2}}{\Gamma(n/2)2^{n/2}}\f$.
|
||||
*/
|
||||
template<class RealType = double>
|
||||
class chi_squared_distribution {
|
||||
public:
|
||||
typedef RealType result_type;
|
||||
typedef RealType input_type;
|
||||
|
||||
class param_type {
|
||||
public:
|
||||
typedef chi_squared_distribution distribution_type;
|
||||
/**
|
||||
* Construct a param_type object. @c n
|
||||
* is the parameter of the distribution.
|
||||
*
|
||||
* Requires: t >=0 && 0 <= p <= 1
|
||||
*/
|
||||
explicit param_type(RealType n_arg = RealType(1))
|
||||
: _n(n_arg)
|
||||
{}
|
||||
/** Returns the @c n parameter of the distribution. */
|
||||
RealType n() const { return _n; }
|
||||
#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
|
||||
/** Writes the parameters of the distribution to a @c std::ostream. */
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_ostream<CharT,Traits>&
|
||||
operator<<(std::basic_ostream<CharT,Traits>& os,
|
||||
const param_type& parm)
|
||||
{
|
||||
os << parm._n;
|
||||
return os;
|
||||
}
|
||||
|
||||
/** Reads the parameters of the distribution from a @c std::istream. */
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_istream<CharT,Traits>&
|
||||
operator>>(std::basic_istream<CharT,Traits>& is, param_type& parm)
|
||||
{
|
||||
is >> parm._n;
|
||||
return is;
|
||||
}
|
||||
#endif
|
||||
/** Returns true if the parameters have the same values. */
|
||||
friend bool operator==(const param_type& lhs, const param_type& rhs)
|
||||
{
|
||||
return lhs._n == rhs._n;
|
||||
}
|
||||
/** Returns true if the parameters have different values. */
|
||||
friend bool operator!=(const param_type& lhs, const param_type& rhs)
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
private:
|
||||
RealType _n;
|
||||
};
|
||||
|
||||
/**
|
||||
* Construct a @c chi_squared_distribution object. @c n
|
||||
* is the parameter of the distribution.
|
||||
*
|
||||
* Requires: t >=0 && 0 <= p <= 1
|
||||
*/
|
||||
explicit chi_squared_distribution(RealType n_arg = RealType(1))
|
||||
: _impl(static_cast<RealType>(n_arg / 2))
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct an @c chi_squared_distribution object from the
|
||||
* parameters.
|
||||
*/
|
||||
explicit chi_squared_distribution(const param_type& parm)
|
||||
: _impl(static_cast<RealType>(parm.n() / 2))
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a random variate distributed according to the
|
||||
* chi squared distribution.
|
||||
*/
|
||||
template<class URNG>
|
||||
RealType operator()(URNG& urng)
|
||||
{
|
||||
return 2 * _impl(urng);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a random variate distributed according to the
|
||||
* chi squared distribution with parameters specified by @c param.
|
||||
*/
|
||||
template<class URNG>
|
||||
RealType operator()(URNG& urng, const param_type& parm) const
|
||||
{
|
||||
return chi_squared_distribution(parm)(urng);
|
||||
}
|
||||
|
||||
/** Returns the @c n parameter of the distribution. */
|
||||
RealType n() const { return 2 * _impl.alpha(); }
|
||||
|
||||
/** Returns the smallest value that the distribution can produce. */
|
||||
RealType min BOOST_PREVENT_MACRO_SUBSTITUTION() const { return 0; }
|
||||
/** Returns the largest value that the distribution can produce. */
|
||||
RealType max BOOST_PREVENT_MACRO_SUBSTITUTION() const
|
||||
{ return (std::numeric_limits<RealType>::infinity)(); }
|
||||
|
||||
/** Returns the parameters of the distribution. */
|
||||
param_type param() const { return param_type(n()); }
|
||||
/** Sets parameters of the distribution. */
|
||||
void param(const param_type& parm)
|
||||
{
|
||||
typedef gamma_distribution<RealType> impl_type;
|
||||
typename impl_type::param_type impl_parm(static_cast<RealType>(parm.n() / 2));
|
||||
_impl.param(impl_parm);
|
||||
}
|
||||
|
||||
/**
|
||||
* Effects: Subsequent uses of the distribution do not depend
|
||||
* on values produced by any engine prior to invoking reset.
|
||||
*/
|
||||
void reset() { _impl.reset(); }
|
||||
|
||||
#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
|
||||
/** Writes the parameters of the distribution to a @c std::ostream. */
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_ostream<CharT,Traits>&
|
||||
operator<<(std::basic_ostream<CharT,Traits>& os,
|
||||
const chi_squared_distribution& c2d)
|
||||
{
|
||||
os << c2d.param();
|
||||
return os;
|
||||
}
|
||||
|
||||
/** Reads the parameters of the distribution from a @c std::istream. */
|
||||
template<class CharT, class Traits>
|
||||
friend std::basic_istream<CharT,Traits>&
|
||||
operator>>(std::basic_istream<CharT,Traits>& is,
|
||||
chi_squared_distribution& c2d)
|
||||
{
|
||||
c2d.read(is);
|
||||
return is;
|
||||
}
|
||||
#endif
|
||||
|
||||
/** Returns true if the two distributions will produce the same
|
||||
sequence of values, given equal generators. */
|
||||
friend bool operator==(const chi_squared_distribution& lhs,
|
||||
const chi_squared_distribution& rhs)
|
||||
{
|
||||
return lhs._impl == rhs._impl;
|
||||
}
|
||||
/** Returns true if the two distributions could produce different
|
||||
sequences of values, given equal generators. */
|
||||
friend bool operator!=(const chi_squared_distribution& lhs,
|
||||
const chi_squared_distribution& rhs)
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
/// @cond show_private
|
||||
|
||||
template<class CharT, class Traits>
|
||||
void read(std::basic_istream<CharT, Traits>& is) {
|
||||
param_type parm;
|
||||
if(is >> parm) {
|
||||
param(parm);
|
||||
}
|
||||
}
|
||||
|
||||
gamma_distribution<RealType> _impl;
|
||||
|
||||
/// @endcond
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,38 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/integrate/null_observer.hpp
|
||||
|
||||
[begin_description]
|
||||
null_observer
|
||||
[end_description]
|
||||
|
||||
Copyright 2009-2011 Karsten Ahnert
|
||||
Copyright 2009-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_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
struct null_observer
|
||||
{
|
||||
template< class State , class Time >
|
||||
void operator()( const State& /* x */ , Time /* t */ ) const
|
||||
{
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace odeint
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_NULL_OBSERVER_HPP_INCLUDED
|
||||
@@ -0,0 +1,53 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2005-2013. 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_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED
|
||||
#define BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
#endif //BOOST_CONTAINER_CONTAINER_DETAIL_CONFIG_INCLUDED
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning (push)
|
||||
#pragma warning (disable : 4127) // conditional expression is constant
|
||||
#pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
|
||||
#pragma warning (disable : 4197) // top-level volatile in cast is ignored
|
||||
#pragma warning (disable : 4244) // possible loss of data
|
||||
#pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
|
||||
#pragma warning (disable : 4267) // conversion from "X" to "Y", possible loss of data
|
||||
#pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
|
||||
#pragma warning (disable : 4284) // odd return type for operator->
|
||||
#pragma warning (disable : 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
|
||||
#pragma warning (disable : 4324) // structure was padded due to __declspec(align(
|
||||
#pragma warning (disable : 4345) // behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized
|
||||
#pragma warning (disable : 4355) // "this" : used in base member initializer list
|
||||
#pragma warning (disable : 4503) // "identifier" : decorated name length exceeded, name was truncated
|
||||
#pragma warning (disable : 4510) // default constructor could not be generated
|
||||
#pragma warning (disable : 4511) // copy constructor could not be generated
|
||||
#pragma warning (disable : 4512) // assignment operator could not be generated
|
||||
#pragma warning (disable : 4514) // unreferenced inline removed
|
||||
#pragma warning (disable : 4521) // Disable "multiple copy constructors specified"
|
||||
#pragma warning (disable : 4522) // "class" : multiple assignment operators specified
|
||||
#pragma warning (disable : 4541) // 'typeid' used on polymorphic type '' with /GR-; unpredictable behavior may result
|
||||
#pragma warning (disable : 4584) // X is already a base-class of Y
|
||||
#pragma warning (disable : 4610) // struct can never be instantiated - user defined constructor required
|
||||
#pragma warning (disable : 4671) // the copy constructor is inaccessible
|
||||
#pragma warning (disable : 4673) // throwing '' the following types will not be considered at the catch site
|
||||
#pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
|
||||
#pragma warning (disable : 4702) // unreachable code
|
||||
#pragma warning (disable : 4706) // assignment within conditional expression
|
||||
#pragma warning (disable : 4710) // function not inlined
|
||||
#pragma warning (disable : 4714) // "function": marked as __forceinline not inlined
|
||||
#pragma warning (disable : 4711) // function selected for automatic inline expansion
|
||||
#pragma warning (disable : 4786) // identifier truncated in debug info
|
||||
#pragma warning (disable : 4996) // "function": was declared deprecated
|
||||
|
||||
#endif //BOOST_MSVC
|
||||
@@ -0,0 +1,45 @@
|
||||
// (C) Copyright Gennadiy Rozental 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/libs/test for the library home page.
|
||||
//
|
||||
//!@file
|
||||
//!@brief contains forward eclarations for Boost.Test data types
|
||||
// ***************************************************************************
|
||||
|
||||
#ifndef BOOST_TEST_FWD_DECL_HPP_011605GER
|
||||
#define BOOST_TEST_FWD_DECL_HPP_011605GER
|
||||
|
||||
namespace boost {
|
||||
|
||||
class execution_monitor;
|
||||
class execution_exception;
|
||||
|
||||
namespace unit_test {
|
||||
|
||||
class test_unit;
|
||||
class test_case;
|
||||
class test_suite;
|
||||
class master_test_suite_t;
|
||||
|
||||
class test_tree_visitor;
|
||||
class test_observer;
|
||||
|
||||
// singletons
|
||||
class unit_test_monitor_t;
|
||||
class unit_test_log_t;
|
||||
|
||||
class unit_test_log_formatter;
|
||||
struct log_entry_data;
|
||||
struct log_checkpoint_data;
|
||||
|
||||
class lazy_ostream;
|
||||
|
||||
} // namespace unit_test
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_TEST_FWD_DECL_HPP_011605GER
|
||||
|
||||
@@ -0,0 +1,672 @@
|
||||
/*=============================================================================
|
||||
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_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ , typename T20 = void_ , typename T21 = void_ , typename T22 = void_ , typename T23 = void_ , typename T24 = void_ , typename T25 = void_ , typename T26 = void_ , typename T27 = void_ , typename T28 = void_ , typename T29 = 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_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , 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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29>
|
||||
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 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29>::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
|
||||
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 , typename detail::call_param<T10 >::type t10)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10));
|
||||
}
|
||||
# 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 , typename T_10>
|
||||
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 , T_10 && t10)
|
||||
{
|
||||
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 , T_10
|
||||
>::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) , std::forward<T_10>( t10)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11>
|
||||
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 , T_10 && t10 , T_11 && t11)
|
||||
{
|
||||
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 , T_10 , T_11
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22 , typename detail::call_param<T23 >::type t23)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22 , typename T_23>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22 , T_23 && t23)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22 , T_23
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22) , std::forward<T_23>( t23)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22 , typename detail::call_param<T23 >::type t23 , typename detail::call_param<T24 >::type t24)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22 , typename T_23 , typename T_24>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22 , T_23 && t23 , T_24 && t24)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22 , T_23 , T_24
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22) , std::forward<T_23>( t23) , std::forward<T_24>( t24)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22 , typename detail::call_param<T23 >::type t23 , typename detail::call_param<T24 >::type t24 , typename detail::call_param<T25 >::type t25)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22 , typename T_23 , typename T_24 , typename T_25>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22 , T_23 && t23 , T_24 && t24 , T_25 && t25)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22 , T_23 , T_24 , T_25
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22) , std::forward<T_23>( t23) , std::forward<T_24>( t24) , std::forward<T_25>( t25)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22 , typename detail::call_param<T23 >::type t23 , typename detail::call_param<T24 >::type t24 , typename detail::call_param<T25 >::type t25 , typename detail::call_param<T26 >::type t26)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22 , typename T_23 , typename T_24 , typename T_25 , typename T_26>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22 , T_23 && t23 , T_24 && t24 , T_25 && t25 , T_26 && t26)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22 , T_23 , T_24 , T_25 , T_26
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22) , std::forward<T_23>( t23) , std::forward<T_24>( t24) , std::forward<T_25>( t25) , std::forward<T_26>( t26)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22 , typename detail::call_param<T23 >::type t23 , typename detail::call_param<T24 >::type t24 , typename detail::call_param<T25 >::type t25 , typename detail::call_param<T26 >::type t26 , typename detail::call_param<T27 >::type t27)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22 , typename T_23 , typename T_24 , typename T_25 , typename T_26 , typename T_27>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22 , T_23 && t23 , T_24 && t24 , T_25 && t25 , T_26 && t26 , T_27 && t27)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22 , T_23 , T_24 , T_25 , T_26 , T_27
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22) , std::forward<T_23>( t23) , std::forward<T_24>( t24) , std::forward<T_25>( t25) , std::forward<T_26>( t26) , std::forward<T_27>( t27)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22 , typename detail::call_param<T23 >::type t23 , typename detail::call_param<T24 >::type t24 , typename detail::call_param<T25 >::type t25 , typename detail::call_param<T26 >::type t26 , typename detail::call_param<T27 >::type t27 , typename detail::call_param<T28 >::type t28)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22 , typename T_23 , typename T_24 , typename T_25 , typename T_26 , typename T_27 , typename T_28>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22 , T_23 && t23 , T_24 && t24 , T_25 && t25 , T_26 && t26 , T_27 && t27 , T_28 && t28)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22 , T_23 , T_24 , T_25 , T_26 , T_27 , T_28
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22) , std::forward<T_23>( t23) , std::forward<T_24>( t24) , std::forward<T_25>( t25) , std::forward<T_26>( t26) , std::forward<T_27>( t27) , std::forward<T_28>( t28)));
|
||||
}
|
||||
# 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 , typename detail::call_param<T10 >::type t10 , typename detail::call_param<T11 >::type t11 , typename detail::call_param<T12 >::type t12 , typename detail::call_param<T13 >::type t13 , typename detail::call_param<T14 >::type t14 , typename detail::call_param<T15 >::type t15 , typename detail::call_param<T16 >::type t16 , typename detail::call_param<T17 >::type t17 , typename detail::call_param<T18 >::type t18 , typename detail::call_param<T19 >::type t19 , typename detail::call_param<T20 >::type t20 , typename detail::call_param<T21 >::type t21 , typename detail::call_param<T22 >::type t22 , typename detail::call_param<T23 >::type t23 , typename detail::call_param<T24 >::type t24 , typename detail::call_param<T25 >::type t25 , typename detail::call_param<T26 >::type t26 , typename detail::call_param<T27 >::type t27 , typename detail::call_param<T28 >::type t28 , typename detail::call_param<T29 >::type t29)
|
||||
{
|
||||
return type(t0,
|
||||
deque_keyed_values_impl<
|
||||
next_index
|
||||
, T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29
|
||||
>::construct(t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29));
|
||||
}
|
||||
# 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 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19 , typename T_20 , typename T_21 , typename T_22 , typename T_23 , typename T_24 , typename T_25 , typename T_26 , typename T_27 , typename T_28 , typename T_29>
|
||||
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 , T_10 && t10 , T_11 && t11 , T_12 && t12 , T_13 && t13 , T_14 && t14 , T_15 && t15 , T_16 && t16 , T_17 && t17 , T_18 && t18 , T_19 && t19 , T_20 && t20 , T_21 && t21 , T_22 && t22 , T_23 && t23 , T_24 && t24 , T_25 && t25 , T_26 && t26 , T_27 && t27 , T_28 && t28 , T_29 && t29)
|
||||
{
|
||||
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 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19 , T_20 , T_21 , T_22 , T_23 , T_24 , T_25 , T_26 , T_27 , T_28 , T_29
|
||||
>::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) , std::forward<T_10>( t10) , std::forward<T_11>( t11) , std::forward<T_12>( t12) , std::forward<T_13>( t13) , std::forward<T_14>( t14) , std::forward<T_15>( t15) , std::forward<T_16>( t16) , std::forward<T_17>( t17) , std::forward<T_18>( t18) , std::forward<T_19>( t19) , std::forward<T_20>( t20) , std::forward<T_21>( t21) , std::forward<T_22>( t22) , std::forward<T_23>( t23) , std::forward<T_24>( t24) , std::forward<T_25>( t25) , std::forward<T_26>( t26) , std::forward<T_27>( t27) , std::forward<T_28>( t28) , std::forward<T_29>( t29)));
|
||||
}
|
||||
# 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_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ , typename T20 = void_ , typename T21 = void_ , typename T22 = void_ , typename T23 = void_ , typename T24 = void_ , typename T25 = void_ , typename T26 = void_ , typename T27 = void_ , typename T28 = void_ , typename T29 = void_>
|
||||
struct deque_keyed_values
|
||||
: deque_keyed_values_impl<mpl::int_<0>, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29>
|
||||
{};
|
||||
}}}
|
||||
@@ -0,0 +1,366 @@
|
||||
// (C) Copyright Gennadiy Rozental 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/libs/test for the library home page.
|
||||
//
|
||||
/// @file
|
||||
/// @brief Defines Unit Test Framework public API
|
||||
// ***************************************************************************
|
||||
|
||||
#ifndef BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
|
||||
#define BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
|
||||
|
||||
// Boost.Test
|
||||
#include <boost/test/framework.hpp>
|
||||
#include <boost/test/tree/auto_registration.hpp>
|
||||
#include <boost/test/tree/test_case_template.hpp>
|
||||
#include <boost/test/tree/global_fixture.hpp>
|
||||
|
||||
|
||||
#include <boost/test/detail/suppress_warnings.hpp>
|
||||
|
||||
|
||||
#include <boost/test/detail/pp_variadic.hpp>
|
||||
|
||||
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** Non-auto (explicit) test case interface ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_TEST_CASE( test_function ) \
|
||||
boost::unit_test::make_test_case( boost::function<void ()>(test_function), \
|
||||
BOOST_TEST_STRINGIZE( test_function ), \
|
||||
__FILE__, __LINE__ )
|
||||
#define BOOST_CLASS_TEST_CASE( test_function, tc_instance ) \
|
||||
boost::unit_test::make_test_case( (test_function), \
|
||||
BOOST_TEST_STRINGIZE( test_function ), \
|
||||
__FILE__, __LINE__, tc_instance )
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_TEST_SUITE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_TEST_SUITE( testsuite_name ) \
|
||||
( new boost::unit_test::test_suite( testsuite_name, __FILE__, __LINE__ ) )
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_AUTO_TEST_SUITE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_AUTO_TEST_SUITE_WITH_DECOR( suite_name, decorators ) \
|
||||
namespace suite_name { \
|
||||
BOOST_AUTO_TU_REGISTRAR( suite_name )( \
|
||||
BOOST_STRINGIZE( suite_name ), \
|
||||
__FILE__, __LINE__, \
|
||||
decorators ); \
|
||||
/**/
|
||||
|
||||
#define BOOST_AUTO_TEST_SUITE_NO_DECOR( suite_name ) \
|
||||
BOOST_AUTO_TEST_SUITE_WITH_DECOR( \
|
||||
suite_name, \
|
||||
boost::unit_test::decorator::collector::instance() ) \
|
||||
/**/
|
||||
|
||||
#if BOOST_PP_VARIADICS
|
||||
#define BOOST_AUTO_TEST_SUITE( ... ) \
|
||||
BOOST_TEST_INVOKE_IF_N_ARGS( 1, \
|
||||
BOOST_AUTO_TEST_SUITE_NO_DECOR, \
|
||||
BOOST_AUTO_TEST_SUITE_WITH_DECOR, \
|
||||
__VA_ARGS__) \
|
||||
/**/
|
||||
|
||||
#else /* BOOST_PP_VARIADICS */
|
||||
|
||||
#define BOOST_AUTO_TEST_SUITE( suite_name ) \
|
||||
BOOST_AUTO_TEST_SUITE_NO_DECOR( suite_name ) \
|
||||
/**/
|
||||
|
||||
|
||||
#endif /* BOOST_PP_VARIADICS */
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_FIXTURE_TEST_SUITE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_FIXTURE_TEST_SUITE_WITH_DECOR(suite_name, F, decorators) \
|
||||
BOOST_AUTO_TEST_SUITE_WITH_DECOR( suite_name, decorators ) \
|
||||
typedef F BOOST_AUTO_TEST_CASE_FIXTURE; \
|
||||
/**/
|
||||
|
||||
#define BOOST_FIXTURE_TEST_SUITE_NO_DECOR( suite_name, F ) \
|
||||
BOOST_AUTO_TEST_SUITE_NO_DECOR( suite_name ) \
|
||||
typedef F BOOST_AUTO_TEST_CASE_FIXTURE; \
|
||||
/**/
|
||||
|
||||
#if BOOST_PP_VARIADICS
|
||||
|
||||
#define BOOST_FIXTURE_TEST_SUITE( ... ) \
|
||||
BOOST_TEST_INVOKE_IF_N_ARGS( 2, \
|
||||
BOOST_FIXTURE_TEST_SUITE_NO_DECOR, \
|
||||
BOOST_FIXTURE_TEST_SUITE_WITH_DECOR, \
|
||||
__VA_ARGS__) \
|
||||
/**/
|
||||
|
||||
#else /* BOOST_PP_VARIADICS */
|
||||
|
||||
#define BOOST_FIXTURE_TEST_SUITE( suite_name, F ) \
|
||||
BOOST_FIXTURE_TEST_SUITE_NO_DECOR( suite_name, F ) \
|
||||
/**/
|
||||
|
||||
|
||||
#endif /* BOOST_PP_VARIADICS */
|
||||
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_AUTO_TEST_SUITE_END ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_AUTO_TEST_SUITE_END() \
|
||||
BOOST_AUTO_TU_REGISTRAR( BOOST_JOIN( end_suite, __LINE__ ) )( 1 ); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
/// @deprecated use decorator instead
|
||||
#define BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES( test_name, n ) \
|
||||
BOOST_TEST_DECORATOR( * boost::unit_test::expected_failures( n ) ) \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_FIXTURE_TEST_CASE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name, F, decorators ) \
|
||||
struct test_name : public F { void test_method(); }; \
|
||||
\
|
||||
static void BOOST_AUTO_TC_INVOKER( test_name )() \
|
||||
{ \
|
||||
BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture entry."); \
|
||||
test_name t; \
|
||||
BOOST_TEST_CHECKPOINT('"' << #test_name << "\" entry."); \
|
||||
t.test_method(); \
|
||||
BOOST_TEST_CHECKPOINT('"' << #test_name << "\" exit."); \
|
||||
} \
|
||||
\
|
||||
struct BOOST_AUTO_TC_UNIQUE_ID( test_name ) {}; \
|
||||
\
|
||||
BOOST_AUTO_TU_REGISTRAR( test_name )( \
|
||||
boost::unit_test::make_test_case( \
|
||||
&BOOST_AUTO_TC_INVOKER( test_name ), \
|
||||
#test_name, __FILE__, __LINE__ ), \
|
||||
decorators ); \
|
||||
\
|
||||
void test_name::test_method() \
|
||||
/**/
|
||||
|
||||
#define BOOST_FIXTURE_TEST_CASE_NO_DECOR( test_name, F ) \
|
||||
BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name, F, \
|
||||
boost::unit_test::decorator::collector::instance() ) \
|
||||
/**/
|
||||
|
||||
#if BOOST_PP_VARIADICS
|
||||
|
||||
#define BOOST_FIXTURE_TEST_CASE( ... ) \
|
||||
BOOST_TEST_INVOKE_IF_N_ARGS( 2, \
|
||||
BOOST_FIXTURE_TEST_CASE_NO_DECOR, \
|
||||
BOOST_FIXTURE_TEST_CASE_WITH_DECOR, \
|
||||
__VA_ARGS__) \
|
||||
/**/
|
||||
|
||||
#else /* BOOST_PP_VARIADICS */
|
||||
|
||||
#define BOOST_FIXTURE_TEST_CASE( test_name, F ) \
|
||||
BOOST_FIXTURE_TEST_CASE_NO_DECOR(test_name, F) \
|
||||
/**/
|
||||
|
||||
|
||||
#endif /* BOOST_PP_VARIADICS */
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_AUTO_TEST_CASE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_AUTO_TEST_CASE_NO_DECOR( test_name ) \
|
||||
BOOST_FIXTURE_TEST_CASE_NO_DECOR( test_name, \
|
||||
BOOST_AUTO_TEST_CASE_FIXTURE ) \
|
||||
/**/
|
||||
|
||||
#define BOOST_AUTO_TEST_CASE_WITH_DECOR( test_name, decorators ) \
|
||||
BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name, \
|
||||
BOOST_AUTO_TEST_CASE_FIXTURE, decorators ) \
|
||||
/**/
|
||||
|
||||
#if BOOST_PP_VARIADICS
|
||||
|
||||
#define BOOST_AUTO_TEST_CASE( ... ) \
|
||||
BOOST_TEST_INVOKE_IF_N_ARGS( 1, \
|
||||
BOOST_AUTO_TEST_CASE_NO_DECOR, \
|
||||
BOOST_AUTO_TEST_CASE_WITH_DECOR, \
|
||||
__VA_ARGS__) \
|
||||
/**/
|
||||
|
||||
#else /* BOOST_PP_VARIADICS */
|
||||
|
||||
#define BOOST_AUTO_TEST_CASE( test_name ) \
|
||||
BOOST_AUTO_TEST_CASE_NO_DECOR( test_name ) \
|
||||
/**/
|
||||
|
||||
|
||||
#endif /* BOOST_PP_VARIADICS */
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_FIXTURE_TEST_CASE_TEMPLATE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_FIXTURE_TEST_CASE_TEMPLATE( test_name, type_name, TL, F ) \
|
||||
template<typename type_name> \
|
||||
struct test_name : public F \
|
||||
{ void test_method(); }; \
|
||||
\
|
||||
struct BOOST_AUTO_TC_INVOKER( test_name ) { \
|
||||
template<typename TestType> \
|
||||
static void run( boost::type<TestType>* = 0 ) \
|
||||
{ \
|
||||
BOOST_TEST_CHECKPOINT('"' << #test_name <<"\" fixture entry."); \
|
||||
test_name<TestType> t; \
|
||||
BOOST_TEST_CHECKPOINT('"' << #test_name << "\" entry."); \
|
||||
t.test_method(); \
|
||||
BOOST_TEST_CHECKPOINT('"' << #test_name << "\" exit."); \
|
||||
} \
|
||||
}; \
|
||||
\
|
||||
BOOST_AUTO_TU_REGISTRAR( test_name )( \
|
||||
boost::unit_test::ut_detail::template_test_case_gen< \
|
||||
BOOST_AUTO_TC_INVOKER( test_name ),TL >( \
|
||||
BOOST_STRINGIZE( test_name ), __FILE__, __LINE__ ), \
|
||||
boost::unit_test::decorator::collector::instance() ); \
|
||||
\
|
||||
template<typename type_name> \
|
||||
void test_name<type_name>::test_method() \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_AUTO_TEST_CASE_TEMPLATE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_AUTO_TEST_CASE_TEMPLATE( test_name, type_name, TL ) \
|
||||
BOOST_FIXTURE_TEST_CASE_TEMPLATE( test_name, type_name, TL, \
|
||||
BOOST_AUTO_TEST_CASE_FIXTURE ) \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_TEST_CASE_TEMPLATE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_TEST_CASE_TEMPLATE( name, typelist ) \
|
||||
boost::unit_test::ut_detail::template_test_case_gen<name,typelist>( \
|
||||
BOOST_TEST_STRINGIZE( name ), __FILE__, __LINE__ ) \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_TEST_CASE_TEMPLATE_FUNCTION ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_TEST_CASE_TEMPLATE_FUNCTION( name, type_name ) \
|
||||
template<typename type_name> \
|
||||
void BOOST_JOIN( name, _impl )( boost::type<type_name>* ); \
|
||||
\
|
||||
struct name { \
|
||||
template<typename TestType> \
|
||||
static void run( boost::type<TestType>* frwrd = 0 ) \
|
||||
{ \
|
||||
BOOST_JOIN( name, _impl )( frwrd ); \
|
||||
} \
|
||||
}; \
|
||||
\
|
||||
template<typename type_name> \
|
||||
void BOOST_JOIN( name, _impl )( boost::type<type_name>* ) \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_GLOBAL_FIXTURE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_GLOBAL_FIXTURE( F ) \
|
||||
static boost::unit_test::ut_detail::global_fixture_impl<F> BOOST_JOIN( gf_, F ) \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_TEST_DECORATOR ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_TEST_DECORATOR( D ) \
|
||||
static boost::unit_test::decorator::collector const& \
|
||||
BOOST_JOIN(decorator_collector,__LINE__) = D; \
|
||||
/**/
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_AUTO_TEST_CASE_FIXTURE ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
namespace boost { namespace unit_test { namespace ut_detail {
|
||||
|
||||
struct nil_t {};
|
||||
|
||||
} // namespace ut_detail
|
||||
} // unit_test
|
||||
} // namespace boost
|
||||
|
||||
// Intentionally is in global namespace, so that FIXTURE_TEST_SUITE can reset it in user code.
|
||||
typedef ::boost::unit_test::ut_detail::nil_t BOOST_AUTO_TEST_CASE_FIXTURE;
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** Auto registration facility helper macros ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#define BOOST_AUTO_TU_REGISTRAR( test_name ) \
|
||||
static boost::unit_test::ut_detail::auto_test_unit_registrar \
|
||||
BOOST_JOIN( BOOST_JOIN( test_name, _registrar ), __LINE__ ) \
|
||||
/**/
|
||||
#define BOOST_AUTO_TC_INVOKER( test_name ) BOOST_JOIN( test_name, _invoker )
|
||||
#define BOOST_AUTO_TC_UNIQUE_ID( test_name ) BOOST_JOIN( test_name, _id )
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** BOOST_TEST_MAIN ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
#if defined(BOOST_TEST_MAIN)
|
||||
|
||||
#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
|
||||
bool init_unit_test() {
|
||||
#else
|
||||
::boost::unit_test::test_suite*
|
||||
init_unit_test_suite( int, char* [] ) {
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_TEST_MODULE
|
||||
using namespace ::boost::unit_test;
|
||||
assign_op( framework::master_test_suite().p_name.value, BOOST_TEST_STRINGIZE( BOOST_TEST_MODULE ).trim( "\"" ), 0 );
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
|
||||
return true;
|
||||
}
|
||||
#else
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
#include <boost/test/detail/enable_warnings.hpp>
|
||||
|
||||
|
||||
#endif // BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
//-----------------------------------------------------------------------------
|
||||
// boost variant/bad_visit.hpp header file
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2002-2003
|
||||
// Eric Friedman
|
||||
//
|
||||
// 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_VARIANT_BAD_VISIT_HPP
|
||||
#define BOOST_VARIANT_BAD_VISIT_HPP
|
||||
|
||||
#include <exception>
|
||||
|
||||
namespace boost {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// class bad_visit
|
||||
//
|
||||
// Exception thrown when a visitation attempt via apply_visitor fails due
|
||||
// to invalid visited subtype or contents.
|
||||
//
|
||||
struct bad_visit
|
||||
: std::exception
|
||||
{
|
||||
public: // std::exception interface
|
||||
|
||||
virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
|
||||
{
|
||||
return "boost::bad_visit: "
|
||||
"failed visitation using boost::apply_visitor";
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_VARIANT_BAD_VISIT_HPP
|
||||
@@ -0,0 +1,33 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
Copyright (c) 2005-2006 Dan Marsden
|
||||
Copyright (c) 2009-2010 Christopher Schmidt
|
||||
|
||||
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_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_AT_IMPL_HPP
|
||||
#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_VALUE_AT_IMPL_HPP
|
||||
|
||||
namespace boost { namespace fusion { namespace extension
|
||||
{
|
||||
template<typename>
|
||||
struct value_at_impl;
|
||||
|
||||
template <>
|
||||
struct value_at_impl<struct_tag>
|
||||
{
|
||||
template <typename Seq, typename N>
|
||||
struct apply
|
||||
: access::struct_member<typename remove_const<Seq>::type, N::value>
|
||||
{};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct value_at_impl<assoc_struct_tag>
|
||||
: value_at_impl<struct_tag>
|
||||
{};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 6.0 KiB |
@@ -0,0 +1,647 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file extends.hpp
|
||||
/// Macros and a base class for defining end-user expression types
|
||||
//
|
||||
// Copyright 2008 Eric Niebler. 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_PROTO_EXTENDS_HPP_EAN_11_1_2006
|
||||
#define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
|
||||
|
||||
#include <cstddef> // for offsetof
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/preprocessor/facilities/empty.hpp>
|
||||
#include <boost/preprocessor/tuple/elem.hpp>
|
||||
#include <boost/preprocessor/control/if.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/iteration/local.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/preprocessor/seq/for_each.hpp>
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/expr.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/generate.hpp>
|
||||
#include <boost/proto/detail/remove_typename.hpp>
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
#ifdef __GNUC__
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x))
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this)))
|
||||
#else
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_OFFSETOF offsetof
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_CONST() const
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TYPENAME() typename
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_NO_(Z, N)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, Const) \
|
||||
BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z, N) \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
|
||||
proto_derived_expr Const() \
|
||||
, proto_domain \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) Const() \
|
||||
{ \
|
||||
typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
|
||||
proto_derived_expr Const() \
|
||||
, proto_domain \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
|
||||
> funop; \
|
||||
return proto_generator()( \
|
||||
funop::call( \
|
||||
*static_cast<proto_derived_expr Const() *>(this) \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a) \
|
||||
) \
|
||||
); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const) \
|
||||
template<typename... A> \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::funop< \
|
||||
proto_derived_expr Const()(A const &...) \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator ()(A const &...a) Const() \
|
||||
{ \
|
||||
typedef boost::proto::result_of::funop< \
|
||||
proto_derived_expr Const()(A const &...) \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
> funop; \
|
||||
return proto_generator()( \
|
||||
funop::call( \
|
||||
*static_cast<proto_derived_expr Const() *>(this) \
|
||||
, a... \
|
||||
) \
|
||||
); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_CHILD(Z, N, DATA) \
|
||||
typedef \
|
||||
typename proto_base_expr::BOOST_PP_CAT(proto_child, N) \
|
||||
BOOST_PP_CAT(proto_child, N); \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
|
||||
Expr proto_expr_; \
|
||||
\
|
||||
typedef Expr proto_base_expr_; /**< INTERNAL ONLY */ \
|
||||
typedef typename proto_base_expr_::proto_base_expr proto_base_expr; \
|
||||
typedef BOOST_PROTO_REMOVE_TYPENAME(Domain) proto_domain; \
|
||||
typedef Derived proto_derived_expr; \
|
||||
typedef Domain::proto_generator proto_generator; \
|
||||
typedef typename proto_base_expr::proto_tag proto_tag; \
|
||||
typedef typename proto_base_expr::proto_args proto_args; \
|
||||
typedef typename proto_base_expr::proto_arity proto_arity; \
|
||||
typedef typename proto_base_expr::proto_grammar proto_grammar; \
|
||||
typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */ \
|
||||
static const long proto_arity_c = proto_base_expr::proto_arity_c; \
|
||||
typedef boost::proto::tag::proto_expr<proto_tag, proto_domain> fusion_tag; \
|
||||
BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \
|
||||
\
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
static proto_derived_expr const make(Expr const &e) \
|
||||
{ \
|
||||
proto_derived_expr that = {e}; \
|
||||
return that; \
|
||||
} \
|
||||
\
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
proto_base_expr &proto_base() \
|
||||
{ \
|
||||
return this->proto_expr_.proto_base(); \
|
||||
} \
|
||||
\
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
proto_base_expr const &proto_base() const \
|
||||
{ \
|
||||
return this->proto_expr_.proto_base(); \
|
||||
} \
|
||||
\
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
operator proto_address_of_hack_type_() const \
|
||||
{ \
|
||||
return boost::addressof(this->proto_base().child0); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
|
||||
typedef void proto_is_aggregate_; \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, Const, Typename) \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4522 \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
Typename() BOOST_PROTO_RESULT_OF< \
|
||||
Typename() This::proto_generator( \
|
||||
Typename() boost::proto::base_expr< \
|
||||
Typename() This::proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
This & \
|
||||
, This Const() & \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator =(This Const() &a) \
|
||||
{ \
|
||||
typedef \
|
||||
Typename() boost::proto::base_expr< \
|
||||
Typename() This::proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
This & \
|
||||
, This Const() & \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*this \
|
||||
, a \
|
||||
}; \
|
||||
return Typename() This::proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
// MSVC 8.0 and higher seem to need copy-assignment operator to be overloaded on *both*
|
||||
// const and non-const rhs arguments.
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) && (BOOST_MSVC > 1310)
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PP_EMPTY, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
|
||||
/**/
|
||||
#else
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
|
||||
/**/
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst) \
|
||||
template<typename A> \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator =(A ThatConst() &a) ThisConst() \
|
||||
{ \
|
||||
typedef \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*static_cast<proto_derived_expr ThisConst() *>(this) \
|
||||
, boost::proto::as_child<proto_domain>(a) \
|
||||
}; \
|
||||
return proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_CONST() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_() \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst) \
|
||||
template<typename A> \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::subscript \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator [](A ThatConst() &a) ThisConst() \
|
||||
{ \
|
||||
typedef \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::subscript \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*static_cast<proto_derived_expr ThisConst() *>(this) \
|
||||
, boost::proto::as_child<proto_domain>(a) \
|
||||
}; \
|
||||
return proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
template<typename Sig> \
|
||||
struct result \
|
||||
{ \
|
||||
typedef \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::funop< \
|
||||
Sig \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
type; \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
#else
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP_CONST \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
#endif
|
||||
|
||||
#define BOOST_PROTO_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived) \
|
||||
typedef typename Derived::proto_extends proto_extends; \
|
||||
using proto_extends::operator =; \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PROTO_TYPENAME) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived) \
|
||||
typedef Derived::proto_extends proto_extends; \
|
||||
using proto_extends::operator =; \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
namespace exprns_
|
||||
{
|
||||
/// \brief Empty type to be used as a dummy template parameter of
|
||||
/// POD expression wrappers. It allows argument-dependent lookup
|
||||
/// to find Proto's operator overloads.
|
||||
///
|
||||
/// \c proto::is_proto_expr allows argument-dependent lookup
|
||||
/// to find Proto's operator overloads. For example:
|
||||
///
|
||||
/// \code
|
||||
/// template<typename T, typename Dummy = proto::is_proto_expr>
|
||||
/// struct my_terminal
|
||||
/// {
|
||||
/// BOOST_PROTO_BASIC_EXTENDS(
|
||||
/// typename proto::terminal<T>::type
|
||||
/// , my_terminal<T>
|
||||
/// , default_domain
|
||||
/// )
|
||||
/// };
|
||||
///
|
||||
/// // ...
|
||||
/// my_terminal<int> _1, _2;
|
||||
/// _1 + _2; // OK, uses proto::operator+
|
||||
/// \endcode
|
||||
///
|
||||
/// Without the second \c Dummy template parameter, Proto's operator
|
||||
/// overloads would not be considered by name lookup.
|
||||
struct is_proto_expr
|
||||
{};
|
||||
|
||||
/// \brief extends\<\> class template for adding behaviors to a Proto expression template
|
||||
///
|
||||
template<
|
||||
typename Expr
|
||||
, typename Derived
|
||||
, typename Domain // = proto::default_domain
|
||||
, long Arity // = Expr::proto_arity_c
|
||||
>
|
||||
struct extends
|
||||
{
|
||||
BOOST_FORCEINLINE
|
||||
extends()
|
||||
: proto_expr_()
|
||||
{}
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
extends(extends const &that)
|
||||
: proto_expr_(that.proto_expr_)
|
||||
{}
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
extends(Expr const &expr_)
|
||||
: proto_expr_(expr_)
|
||||
{}
|
||||
|
||||
typedef extends proto_extends;
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#include <boost/proto/detail/extends_funop_const.hpp>
|
||||
};
|
||||
|
||||
/// \brief extends\<\> class template for adding behaviors to a Proto expression template
|
||||
///
|
||||
template<typename Expr, typename Derived, typename Domain>
|
||||
struct extends<Expr, Derived, Domain, 0>
|
||||
{
|
||||
BOOST_FORCEINLINE
|
||||
extends()
|
||||
: proto_expr_()
|
||||
{}
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
extends(extends const &that)
|
||||
: proto_expr_(that.proto_expr_)
|
||||
{}
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
extends(Expr const &expr_)
|
||||
: proto_expr_(expr_)
|
||||
{}
|
||||
|
||||
typedef extends proto_extends;
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#include <boost/proto/detail/extends_funop.hpp>
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename This, typename Fun, typename Domain>
|
||||
struct virtual_member
|
||||
{
|
||||
typedef Domain proto_domain;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef virtual_member<This, Fun, Domain> proto_derived_expr;
|
||||
typedef tag::member proto_tag;
|
||||
typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args;
|
||||
typedef mpl::long_<2> proto_arity;
|
||||
typedef detail::not_a_valid_type proto_address_of_hack_type_;
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */
|
||||
static const long proto_arity_c = 2;
|
||||
typedef boost::proto::tag::proto_expr<proto_tag, Domain> fusion_tag;
|
||||
typedef This &proto_child0;
|
||||
typedef expr<tag::terminal, term<Fun> > const &proto_child1;
|
||||
typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr;
|
||||
typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar;
|
||||
typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
|
||||
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#define BOOST_PROTO_NO_WAVE_OUTPUT
|
||||
#include <boost/proto/detail/extends_funop.hpp>
|
||||
#undef BOOST_PROTO_NO_WAVE_OUTPUT
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
proto_base_expr const proto_base() const
|
||||
{
|
||||
proto_base_expr that = {this->child0(), this->child1()};
|
||||
return that;
|
||||
}
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
proto_child0 child0() const
|
||||
{
|
||||
using std::size_t;
|
||||
return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
|
||||
}
|
||||
|
||||
BOOST_FORCEINLINE
|
||||
proto_child1 child1() const
|
||||
{
|
||||
static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM) \
|
||||
boost::proto::exprns_::virtual_member< \
|
||||
proto_derived_expr \
|
||||
, BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
|
||||
, DOMAIN \
|
||||
> BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
|
||||
/**/
|
||||
|
||||
/// \brief For declaring virtual data members in an extension class.
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN) \
|
||||
union \
|
||||
{ \
|
||||
char proto_member_union_start_; \
|
||||
BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ) \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
/// \brief For declaring virtual data members in an extension class.
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
|
||||
BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain) \
|
||||
/**/
|
||||
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,409 @@
|
||||
// Copyright John Maddock 2005-2006.
|
||||
// Use, modification and distribution are subject to the
|
||||
// Boost Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_MATH_TOOLS_PRECISION_INCLUDED
|
||||
#define BOOST_MATH_TOOLS_PRECISION_INCLUDED
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/math/policies/policy.hpp>
|
||||
|
||||
// These two are for LDBL_MAN_DIG:
|
||||
#include <limits.h>
|
||||
#include <math.h>
|
||||
|
||||
namespace boost{ namespace math
|
||||
{
|
||||
namespace tools
|
||||
{
|
||||
// If T is not specialized, the functions digits, max_value and min_value,
|
||||
// all get synthesised automatically from std::numeric_limits.
|
||||
// However, if numeric_limits is not specialised for type RealType,
|
||||
// for example with NTL::RR type, then you will get a compiler error
|
||||
// when code tries to use these functions, unless you explicitly specialise them.
|
||||
|
||||
// For example if the precision of RealType varies at runtime,
|
||||
// then numeric_limits support may not be appropriate,
|
||||
// see boost/math/tools/ntl.hpp for examples like
|
||||
// template <> NTL::RR max_value<NTL::RR> ...
|
||||
// See Conceptual Requirements for Real Number Types.
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR int digits(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) BOOST_NOEXCEPT
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
|
||||
BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::radix == 2 || ::std::numeric_limits<T>::radix == 10);
|
||||
#else
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::radix == 2 || ::std::numeric_limits<T>::radix == 10);
|
||||
#endif
|
||||
return std::numeric_limits<T>::radix == 2
|
||||
? std::numeric_limits<T>::digits
|
||||
: ((std::numeric_limits<T>::digits + 1) * 1000L) / 301L;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
|
||||
#else
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
|
||||
#endif
|
||||
return (std::numeric_limits<T>::max)();
|
||||
} // Also used as a finite 'infinite' value for - and +infinity, for example:
|
||||
// -max_value<double> = -1.79769e+308, max_value<double> = 1.79769e+308.
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
BOOST_STATIC_ASSERT( ::std::numeric_limits<T>::is_specialized);
|
||||
#else
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
|
||||
#endif
|
||||
return (std::numeric_limits<T>::min)();
|
||||
}
|
||||
|
||||
namespace detail{
|
||||
//
|
||||
// Logarithmic limits come next, note that although
|
||||
// we can compute these from the log of the max value
|
||||
// that is not in general thread safe (if we cache the value)
|
||||
// so it's better to specialise these:
|
||||
//
|
||||
// For type float first:
|
||||
//
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return 88.0f;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<128>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return -87.0f;
|
||||
}
|
||||
//
|
||||
// Now double:
|
||||
//
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return 709.0;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<1024>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return -708.0;
|
||||
}
|
||||
//
|
||||
// 80 and 128-bit long doubles:
|
||||
//
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_max_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return 11356.0L;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_min_value(const mpl::int_<16384>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return -11355.0L;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T log_max_value(const mpl::int_<0>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
#ifdef __SUNPRO_CC
|
||||
static const T m = boost::math::tools::max_value<T>();
|
||||
static const T val = log(m);
|
||||
#else
|
||||
static const T val = log(boost::math::tools::max_value<T>());
|
||||
#endif
|
||||
return val;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T log_min_value(const mpl::int_<0>& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
#ifdef __SUNPRO_CC
|
||||
static const T m = boost::math::tools::min_value<T>();
|
||||
static const T val = log(m);
|
||||
#else
|
||||
static const T val = log(boost::math::tools::min_value<T>());
|
||||
#endif
|
||||
return val;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T epsilon(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return std::numeric_limits<T>::epsilon();
|
||||
}
|
||||
|
||||
#if defined(__GNUC__) && ((LDBL_MANT_DIG == 106) || (__LDBL_MANT_DIG__ == 106))
|
||||
template <>
|
||||
inline BOOST_MATH_CONSTEXPR long double epsilon<long double>(const mpl::true_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(long double)) BOOST_MATH_NOEXCEPT(long double)
|
||||
{
|
||||
// numeric_limits on Darwin (and elsewhere) tells lies here:
|
||||
// the issue is that long double on a few platforms is
|
||||
// really a "double double" which has a non-contiguous
|
||||
// mantissa: 53 bits followed by an unspecified number of
|
||||
// zero bits, followed by 53 more bits. Thus the apparent
|
||||
// precision of the type varies depending where it's been.
|
||||
// Set epsilon to the value that a 106 bit fixed mantissa
|
||||
// type would have, as that will give us sensible behaviour everywhere.
|
||||
//
|
||||
// This static assert fails for some unknown reason, so
|
||||
// disabled for now...
|
||||
// BOOST_STATIC_ASSERT(std::numeric_limits<long double>::digits == 106);
|
||||
return 2.4651903288156618919116517665087e-32L;
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
inline T epsilon(const mpl::false_& BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(T))
|
||||
{
|
||||
// Note: don't cache result as precision may vary at runtime:
|
||||
BOOST_MATH_STD_USING // for ADL of std names
|
||||
return ldexp(static_cast<T>(1), 1-policies::digits<T, policies::policy<> >());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
struct log_limit_traits
|
||||
{
|
||||
typedef typename mpl::if_c<
|
||||
(std::numeric_limits<T>::radix == 2) &&
|
||||
(std::numeric_limits<T>::max_exponent == 128
|
||||
|| std::numeric_limits<T>::max_exponent == 1024
|
||||
|| std::numeric_limits<T>::max_exponent == 16384),
|
||||
mpl::int_<(std::numeric_limits<T>::max_exponent > INT_MAX ? INT_MAX : static_cast<int>(std::numeric_limits<T>::max_exponent))>,
|
||||
mpl::int_<0>
|
||||
>::type tag_type;
|
||||
BOOST_STATIC_CONSTANT(bool, value = tag_type::value ? true : false);
|
||||
BOOST_STATIC_ASSERT(::std::numeric_limits<T>::is_specialized || (value == 0));
|
||||
};
|
||||
|
||||
template <class T, bool b> struct log_limit_noexcept_traits_imp : public log_limit_traits<T> {};
|
||||
template <class T> struct log_limit_noexcept_traits_imp<T, false> : public boost::integral_constant<bool, false> {};
|
||||
|
||||
template <class T>
|
||||
struct log_limit_noexcept_traits : public log_limit_noexcept_traits_imp<T, BOOST_MATH_IS_FLOAT(T)> {};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4309)
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_max_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT_IF(detail::log_limit_noexcept_traits<T>::value)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
return detail::log_max_value<T>(typename detail::log_limit_traits<T>::tag_type());
|
||||
#else
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
|
||||
BOOST_MATH_STD_USING
|
||||
static const T val = log((std::numeric_limits<T>::max)());
|
||||
return val;
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T log_min_value(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T)) BOOST_NOEXCEPT_IF(detail::log_limit_noexcept_traits<T>::value)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
return detail::log_min_value<T>(typename detail::log_limit_traits<T>::tag_type());
|
||||
#else
|
||||
BOOST_ASSERT(::std::numeric_limits<T>::is_specialized);
|
||||
BOOST_MATH_STD_USING
|
||||
static const T val = log((std::numeric_limits<T>::min)());
|
||||
return val;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T epsilon(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(T)) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
||||
return detail::epsilon<T>(mpl::bool_< ::std::numeric_limits<T>::is_specialized>());
|
||||
#else
|
||||
return ::std::numeric_limits<T>::is_specialized ?
|
||||
detail::epsilon<T>(mpl::true_()) :
|
||||
detail::epsilon<T>(mpl::false_());
|
||||
#endif
|
||||
}
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.00034526698300124390839884978618400831996329879769945L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.1490116119384765625e-7L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.32927225399135962333569506281281311031656150598474e-9L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T root_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.1387778780781445675529539585113525390625e-16L);
|
||||
}
|
||||
|
||||
template <class T, class Tag>
|
||||
inline T root_epsilon_imp(const T*, const Tag&)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
static const T r_eps = sqrt(tools::epsilon<T>());
|
||||
return r_eps;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T root_epsilon_imp(const T*, const mpl::int_<0>&)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(tools::epsilon<T>());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.0049215666011518482998719164346805794944150447839903L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(6.05545445239333906078989272793696693569753008995e-6L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(4.76837158203125e-7L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T cbrt_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(5.7749313854154005630396773604745549542403508090496e-12L);
|
||||
}
|
||||
|
||||
template <class T, class Tag>
|
||||
inline T cbrt_epsilon_imp(const T*, const Tag&)
|
||||
{
|
||||
BOOST_MATH_STD_USING;
|
||||
static const T cbrt_eps = pow(tools::epsilon<T>(), T(1) / 3);
|
||||
return cbrt_eps;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T cbrt_epsilon_imp(const T*, const mpl::int_<0>&)
|
||||
{
|
||||
BOOST_MATH_STD_USING;
|
||||
return pow(tools::epsilon<T>(), T(1) / 3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<24>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.018581361171917516667460937040007436176452688944747L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<53>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.0001220703125L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<64>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.18145860519450699870567321328132261891067079047605e-4L);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T forth_root_epsilon_imp(const T*, const mpl::int_<113>&) BOOST_MATH_NOEXCEPT(T)
|
||||
{
|
||||
return static_cast<T>(0.37252902984619140625e-8L);
|
||||
}
|
||||
|
||||
template <class T, class Tag>
|
||||
inline T forth_root_epsilon_imp(const T*, const Tag&)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
static const T r_eps = sqrt(sqrt(tools::epsilon<T>()));
|
||||
return r_eps;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T forth_root_epsilon_imp(const T*, const mpl::int_<0>&)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(sqrt(tools::epsilon<T>()));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
struct root_epsilon_traits
|
||||
{
|
||||
typedef mpl::int_< (::std::numeric_limits<T>::radix == 2) ? std::numeric_limits<T>::digits : 0> tag_type;
|
||||
BOOST_STATIC_CONSTANT(bool, has_noexcept = (tag_type::value == 113) || (tag_type::value == 64) || (tag_type::value == 53) || (tag_type::value == 24));
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T root_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept)
|
||||
{
|
||||
return detail::root_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T cbrt_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept)
|
||||
{
|
||||
return detail::cbrt_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline BOOST_MATH_CONSTEXPR T forth_root_epsilon() BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(T) && detail::root_epsilon_traits<T>::has_noexcept)
|
||||
{
|
||||
return detail::forth_root_epsilon_imp(static_cast<T const*>(0), typename detail::root_epsilon_traits<T>::tag_type());
|
||||
}
|
||||
|
||||
} // namespace tools
|
||||
} // namespace math
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_MATH_TOOLS_PRECISION_INCLUDED
|
||||
|
||||
@@ -0,0 +1,270 @@
|
||||
// (C) Copyright Jeremy Siek 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)
|
||||
|
||||
#ifndef BOOST_PROPERTY_HPP
|
||||
#define BOOST_PROPERTY_HPP
|
||||
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/has_xxx.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
struct no_property {};
|
||||
|
||||
template <class Tag, class T, class Base = no_property>
|
||||
struct property {
|
||||
typedef Base next_type;
|
||||
typedef Tag tag_type;
|
||||
typedef T value_type;
|
||||
property(const T& v = T()) : m_value(v) { }
|
||||
property(const T& v, const Base& b) : m_value(v), m_base(b) { }
|
||||
// copy constructor and assignment operator will be generated by compiler
|
||||
|
||||
T m_value;
|
||||
Base m_base;
|
||||
};
|
||||
|
||||
// Kinds of properties
|
||||
namespace graph_introspect_detail {
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(kind)
|
||||
template <typename T, bool Cond> struct get_kind {typedef void type;};
|
||||
template <typename T> struct get_kind<T, true> {typedef typename T::kind type;};
|
||||
}
|
||||
|
||||
// Having a default is to make this trait work for any type, not just valid
|
||||
// properties, to work around VC++ <= 10 bugs related to SFINAE in
|
||||
// compressed_sparse_row_graph's get functions and similar
|
||||
template <class PropertyTag>
|
||||
struct property_kind:
|
||||
graph_introspect_detail::get_kind<PropertyTag, graph_introspect_detail::has_kind<PropertyTag>::value>
|
||||
{};
|
||||
|
||||
// Some standard properties defined independently of Boost.Graph:
|
||||
enum vertex_all_t {vertex_all};
|
||||
enum edge_all_t {edge_all};
|
||||
enum graph_all_t {graph_all};
|
||||
enum vertex_bundle_t {vertex_bundle};
|
||||
enum edge_bundle_t {edge_bundle};
|
||||
enum graph_bundle_t {graph_bundle};
|
||||
|
||||
// Code to look up one property in a property list:
|
||||
template <typename PList, typename PropName, typename Enable = void>
|
||||
struct lookup_one_property_internal {BOOST_STATIC_CONSTANT(bool, found = false); typedef void type;};
|
||||
|
||||
// Special-case properties (vertex_all, edge_all, graph_all)
|
||||
#define BGL_ALL_PROP(tag) \
|
||||
template <typename T> \
|
||||
struct lookup_one_property_internal<T, tag> { \
|
||||
BOOST_STATIC_CONSTANT(bool, found = true); \
|
||||
typedef T type; \
|
||||
static T& lookup(T& x, tag) {return x;} \
|
||||
static const T& lookup(const T& x, tag) {return x;} \
|
||||
}; \
|
||||
template <typename Tag, typename T, typename Base> \
|
||||
struct lookup_one_property_internal<property<Tag, T, Base>, tag> { /* Avoid ambiguity */ \
|
||||
BOOST_STATIC_CONSTANT(bool, found = true); \
|
||||
typedef property<Tag, T, Base> type; \
|
||||
static type& lookup(type& x, tag) {return x;} \
|
||||
static const type& lookup(const type& x, tag) {return x;} \
|
||||
};
|
||||
|
||||
BGL_ALL_PROP(vertex_all_t)
|
||||
BGL_ALL_PROP(edge_all_t)
|
||||
BGL_ALL_PROP(graph_all_t)
|
||||
#undef BGL_ALL_PROP
|
||||
|
||||
// *_bundled; these need to be macros rather than inheritance to resolve ambiguities
|
||||
#define BGL_DO_ONE_BUNDLE_TYPE(kind) \
|
||||
template <typename T> \
|
||||
struct lookup_one_property_internal<T, BOOST_JOIN(kind, _bundle_t)> { \
|
||||
BOOST_STATIC_CONSTANT(bool, found = true); \
|
||||
typedef T type; \
|
||||
static T& lookup(T& x, BOOST_JOIN(kind, _bundle_t)) {return x;} \
|
||||
static const T& lookup(const T& x, BOOST_JOIN(kind, _bundle_t)) {return x;} \
|
||||
}; \
|
||||
\
|
||||
template <typename Tag, typename T, typename Base> \
|
||||
struct lookup_one_property_internal<property<Tag, T, Base>, BOOST_JOIN(kind, _bundle_t)>: lookup_one_property_internal<Base, BOOST_JOIN(kind, _bundle_t)> { \
|
||||
private: \
|
||||
typedef lookup_one_property_internal<Base, BOOST_JOIN(kind, _bundle_t)> base_type; \
|
||||
public: \
|
||||
template <typename BundleTag> \
|
||||
static typename lazy_enable_if_c<(base_type::found && (is_same<BundleTag, BOOST_JOIN(kind, _bundle_t)>::value)), \
|
||||
add_reference<typename base_type::type> >::type \
|
||||
lookup(property<Tag, T, Base>& p, BundleTag) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
|
||||
template <typename BundleTag> \
|
||||
static typename lazy_enable_if_c<(base_type::found && (is_same<BundleTag, BOOST_JOIN(kind, _bundle_t)>::value)), \
|
||||
add_reference<const typename base_type::type> >::type \
|
||||
lookup(const property<Tag, T, Base>& p, BundleTag) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
|
||||
}; \
|
||||
|
||||
BGL_DO_ONE_BUNDLE_TYPE(vertex)
|
||||
BGL_DO_ONE_BUNDLE_TYPE(edge)
|
||||
BGL_DO_ONE_BUNDLE_TYPE(graph)
|
||||
#undef BGL_DO_ONE_BUNDLE_TYPE
|
||||
|
||||
// Normal old-style properties; second case also handles chaining of bundled property accesses
|
||||
template <typename Tag, typename T, typename Base>
|
||||
struct lookup_one_property_internal<boost::property<Tag, T, Base>, Tag> {
|
||||
BOOST_STATIC_CONSTANT(bool, found = true);
|
||||
typedef property<Tag, T, Base> prop;
|
||||
typedef T type;
|
||||
template <typename U>
|
||||
static typename enable_if<is_same<prop, U>, T&>::type
|
||||
lookup(U& prop, const Tag&) {return prop.m_value;}
|
||||
template <typename U>
|
||||
static typename enable_if<is_same<prop, U>, const T&>::type
|
||||
lookup(const U& prop, const Tag&) {return prop.m_value;}
|
||||
};
|
||||
|
||||
template <typename Tag, typename T, typename Base, typename PropName>
|
||||
struct lookup_one_property_internal<boost::property<Tag, T, Base>, PropName>: lookup_one_property_internal<Base, PropName> {
|
||||
private:
|
||||
typedef lookup_one_property_internal<Base, PropName> base_type;
|
||||
public:
|
||||
template <typename PL>
|
||||
static typename lazy_enable_if<is_same<PL, boost::property<Tag, T, Base> >,
|
||||
add_reference<typename base_type::type> >::type
|
||||
lookup(PL& prop, const PropName& tag) {
|
||||
return base_type::lookup(prop.m_base, tag);
|
||||
}
|
||||
template <typename PL>
|
||||
static typename lazy_enable_if<is_same<PL, boost::property<Tag, T, Base> >,
|
||||
add_reference<const typename base_type::type> >::type
|
||||
lookup(const PL& prop, const PropName& tag) {
|
||||
return base_type::lookup(prop.m_base, tag);
|
||||
}
|
||||
};
|
||||
|
||||
// Pointer-to-member access to bundled properties
|
||||
#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
|
||||
template <typename T, typename TMaybeBase, typename R>
|
||||
struct lookup_one_property_internal<T, R TMaybeBase::*, typename enable_if<is_base_of<TMaybeBase, T> >::type> {
|
||||
BOOST_STATIC_CONSTANT(bool, found = true);
|
||||
typedef R type;
|
||||
static R& lookup(T& x, R TMaybeBase::*ptr) {return x.*ptr;}
|
||||
static const R& lookup(const T& x, R TMaybeBase::*ptr) {return x.*ptr;}
|
||||
};
|
||||
#endif
|
||||
|
||||
// Version of above handling const property lists properly
|
||||
template <typename T, typename Tag>
|
||||
struct lookup_one_property: lookup_one_property_internal<T, Tag> {};
|
||||
|
||||
template <typename T, typename Tag>
|
||||
struct lookup_one_property<const T, Tag> {
|
||||
BOOST_STATIC_CONSTANT(bool, found = (lookup_one_property_internal<T, Tag>::found));
|
||||
typedef const typename lookup_one_property_internal<T, Tag>::type type;
|
||||
template <typename U>
|
||||
static typename lazy_enable_if<is_same<T, U>,
|
||||
add_reference<const typename lookup_one_property_internal<T, Tag>::type> >::type
|
||||
lookup(const U& p, Tag tag) {
|
||||
return lookup_one_property_internal<T, Tag>::lookup(p, tag);
|
||||
}
|
||||
};
|
||||
|
||||
// The BGL properties specialize property_kind and
|
||||
// property_num, and use enum's for the Property type (see
|
||||
// graph/properties.hpp), but the user may want to use a class
|
||||
// instead with a nested kind type and num. Also, we may want to
|
||||
// switch BGL back to using class types for properties at some point.
|
||||
|
||||
template <class P>
|
||||
struct has_property : boost::mpl::true_ {};
|
||||
template <>
|
||||
struct has_property<no_property> : boost::mpl::false_ {};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/pending/detail/property.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
template <class PropertyList, class Tag>
|
||||
struct property_value: lookup_one_property<PropertyList, Tag> {};
|
||||
|
||||
template <class PropertyList, class Tag>
|
||||
inline typename lookup_one_property<PropertyList, Tag>::type&
|
||||
get_property_value(PropertyList& p, Tag tag) {
|
||||
return lookup_one_property<PropertyList, Tag>::lookup(p, tag);
|
||||
}
|
||||
|
||||
template <class PropertyList, class Tag>
|
||||
inline const typename lookup_one_property<PropertyList, Tag>::type&
|
||||
get_property_value(const PropertyList& p, Tag tag) {
|
||||
return lookup_one_property<PropertyList, Tag>::lookup(p, tag);
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
/** This trait returns true if T is no_property. */
|
||||
template <typename T>
|
||||
struct is_no_property
|
||||
: mpl::bool_<is_same<T, no_property>::value>
|
||||
{ };
|
||||
|
||||
template <typename PList, typename Tag>
|
||||
class lookup_one_property_f;
|
||||
|
||||
template <typename PList, typename Tag, typename F> struct lookup_one_property_f_result;
|
||||
|
||||
template <typename PList, typename Tag>
|
||||
struct lookup_one_property_f_result<PList, Tag, const lookup_one_property_f<PList, Tag>(PList)> {
|
||||
typedef typename lookup_one_property<PList, Tag>::type type;
|
||||
};
|
||||
|
||||
template <typename PList, typename Tag>
|
||||
struct lookup_one_property_f_result<PList, Tag, const lookup_one_property_f<PList, Tag>(PList&)> {
|
||||
typedef typename lookup_one_property<PList, Tag>::type& type;
|
||||
};
|
||||
|
||||
template <typename PList, typename Tag>
|
||||
struct lookup_one_property_f_result<PList, Tag, const lookup_one_property_f<PList, Tag>(const PList&)> {
|
||||
typedef const typename lookup_one_property<PList, Tag>::type& type;
|
||||
};
|
||||
|
||||
template <typename PList, typename Tag>
|
||||
class lookup_one_property_f {
|
||||
Tag tag;
|
||||
public:
|
||||
lookup_one_property_f(Tag tag): tag(tag) {}
|
||||
template <typename F> struct result: lookup_one_property_f_result<PList, Tag, F> {};
|
||||
|
||||
typename lookup_one_property_f_result<PList, Tag, const lookup_one_property_f(PList&)>::type
|
||||
operator()(PList& pl) const {
|
||||
return lookup_one_property<PList, Tag>::lookup(pl, tag);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
namespace detail {
|
||||
// Stuff for directed_graph and undirected_graph to skip over their first
|
||||
// vertex_index and edge_index properties when providing vertex_all and
|
||||
// edge_all; make sure you know the exact structure of your properties if you
|
||||
// use there.
|
||||
struct remove_first_property {
|
||||
template <typename F>
|
||||
struct result {
|
||||
typedef typename boost::function_traits<F>::arg1_type a1;
|
||||
typedef typename boost::remove_reference<a1>::type non_ref;
|
||||
typedef typename non_ref::next_type nx;
|
||||
typedef typename boost::mpl::if_<boost::is_const<non_ref>, boost::add_const<nx>, nx>::type with_const;
|
||||
typedef typename boost::add_reference<with_const>::type type;
|
||||
};
|
||||
template <typename Prop>
|
||||
typename Prop::next_type& operator()(Prop& p) const {return p.m_base;}
|
||||
template <typename Prop>
|
||||
const typename Prop::next_type& operator()(const Prop& p) const {return p.m_base;}
|
||||
};
|
||||
}
|
||||
|
||||
} // namesapce boost
|
||||
|
||||
#endif /* BOOST_PROPERTY_HPP */
|
||||
@@ -0,0 +1,121 @@
|
||||
// Boost.Range library
|
||||
//
|
||||
// Copyright Thorsten Ottosen 2003-2004. 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)
|
||||
//
|
||||
// For more information, see http://www.boost.org/libs/range/
|
||||
//
|
||||
|
||||
#ifndef BOOST_RANGE_DETAIL_DIFFERENCE_TYPE_HPP
|
||||
#define BOOST_RANGE_DETAIL_DIFFERENCE_TYPE_HPP
|
||||
|
||||
#include <boost/range/detail/common.hpp>
|
||||
#include <boost/iterator/iterator_traits.hpp>
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// missing partial specialization workaround.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template< typename T >
|
||||
struct range_difference_type_;
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<std_container_>
|
||||
{
|
||||
template< typename C >
|
||||
struct pts
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<std_pair_>
|
||||
{
|
||||
template< typename P >
|
||||
struct pts
|
||||
{
|
||||
typedef BOOST_RANGE_DEDUCED_TYPENAME boost::iterator_difference< BOOST_DEDUCED_TYPENAME P::first_type>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<array_>
|
||||
{
|
||||
template< typename A >
|
||||
struct pts
|
||||
{
|
||||
typedef std::ptrdiff_t type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<char_array_>
|
||||
{
|
||||
template< typename A >
|
||||
struct pts
|
||||
{
|
||||
typedef std::ptrdiff_t type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<char_ptr_>
|
||||
{
|
||||
template< typename S >
|
||||
struct pts
|
||||
{
|
||||
typedef std::ptrdiff_t type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<const_char_ptr_>
|
||||
{
|
||||
template< typename S >
|
||||
struct pts
|
||||
{
|
||||
typedef std::ptrdiff_t type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<wchar_t_ptr_>
|
||||
{
|
||||
template< typename S >
|
||||
struct pts
|
||||
{
|
||||
typedef std::ptrdiff_t type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct range_difference_type_<const_wchar_t_ptr_>
|
||||
{
|
||||
template< typename S >
|
||||
struct pts
|
||||
{
|
||||
typedef std::ptrdiff_t type;
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template< typename C >
|
||||
class range_difference
|
||||
{
|
||||
typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
|
||||
public:
|
||||
typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range_difference_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
#ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
|
||||
#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
// detail/sp_nullptr_t.hpp
|
||||
//
|
||||
// Copyright 2013 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
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined( BOOST_NO_CXX11_NULLPTR )
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
|
||||
|
||||
typedef decltype(nullptr) sp_nullptr_t;
|
||||
|
||||
#else
|
||||
|
||||
typedef std::nullptr_t sp_nullptr_t;
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // !defined( BOOST_NO_CXX11_NULLPTR )
|
||||
|
||||
#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
|
||||
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* 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)
|
||||
*
|
||||
* Copyright (c) 2012 Hartmut Kaiser
|
||||
* Copyright (c) 2014 Andrey Semashev
|
||||
*/
|
||||
/*!
|
||||
* \file atomic/detail/config.hpp
|
||||
*
|
||||
* This header defines macros for linking with compiled library of Boost.Atomic
|
||||
*/
|
||||
|
||||
#ifndef BOOST_ATOMIC_DETAIL_LINK_HPP_INCLUDED_
|
||||
#define BOOST_ATOMIC_DETAIL_LINK_HPP_INCLUDED_
|
||||
|
||||
#include <boost/atomic/detail/config.hpp>
|
||||
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Set up dll import/export options
|
||||
#if (defined(BOOST_ATOMIC_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && \
|
||||
!defined(BOOST_ATOMIC_STATIC_LINK)
|
||||
|
||||
#if defined(BOOST_ATOMIC_SOURCE)
|
||||
#define BOOST_ATOMIC_DECL BOOST_SYMBOL_EXPORT
|
||||
#define BOOST_ATOMIC_BUILD_DLL
|
||||
#else
|
||||
#define BOOST_ATOMIC_DECL BOOST_SYMBOL_IMPORT
|
||||
#endif
|
||||
|
||||
#endif // building a shared library
|
||||
|
||||
#ifndef BOOST_ATOMIC_DECL
|
||||
#define BOOST_ATOMIC_DECL
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Auto library naming
|
||||
#if !defined(BOOST_ATOMIC_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \
|
||||
!defined(BOOST_ATOMIC_NO_LIB)
|
||||
|
||||
#define BOOST_LIB_NAME boost_atomic
|
||||
|
||||
// tell the auto-link code to select a dll when required:
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ATOMIC_DYN_LINK)
|
||||
#define BOOST_DYN_LINK
|
||||
#endif
|
||||
|
||||
#include <boost/config/auto_link.hpp>
|
||||
|
||||
#endif // auto-linking disabled
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,36 @@
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
|
||||
//
|
||||
// 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://boostorg.github.com/compute for more information.
|
||||
//---------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_COMPUTE_DETAIL_GETENV_HPP
|
||||
#define BOOST_COMPUTE_DETAIL_GETENV_HPP
|
||||
|
||||
#include <cstdlib>
|
||||
|
||||
namespace boost {
|
||||
namespace compute {
|
||||
namespace detail {
|
||||
|
||||
inline const char* getenv(const char *env_var)
|
||||
{
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4996)
|
||||
#endif
|
||||
return std::getenv(env_var);
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
}
|
||||
|
||||
} // end detail namespace
|
||||
} // end compute namespace
|
||||
} // end boost namespace
|
||||
|
||||
#endif // BOOST_COMPUTE_DETAIL_GETENV_HPP
|
||||
@@ -0,0 +1,33 @@
|
||||
CC = gcc
|
||||
CFLAGS = -O2 -Wall -I. -D_WIN32
|
||||
|
||||
# Default rules
|
||||
%.o: %.c
|
||||
${CC} ${CFLAGS} -c $<
|
||||
%.o: %.f
|
||||
${FC} ${FFLAGS} -c $<
|
||||
%.o: %.F
|
||||
${FC} ${FFLAGS} -c $<
|
||||
%.o: %.f90
|
||||
${FC} ${FFLAGS} -c $<
|
||||
%.o: %.F90
|
||||
${FC} ${FFLAGS} -c $<
|
||||
|
||||
all: libqra64.a qracodes.exe
|
||||
|
||||
OBJS1 = normrnd.o npfwht.o pdmath.o qra12_63_64_irr_b.o \
|
||||
qra13_64_64_irr_e.o qracodes.o
|
||||
|
||||
libqra64.a: $(OBJS1)
|
||||
ar cr libqra64.a $(OBJS1)
|
||||
ranlib libqra64.a
|
||||
|
||||
OBJS2 = main.o
|
||||
|
||||
qracodes.exe: $(OBJS2)
|
||||
${CC} -o qracodes.exe $(OBJS2) libqra64.a -lm
|
||||
|
||||
.PHONY : clean
|
||||
|
||||
clean:
|
||||
$(RM) *.o libqra64.a qracodes.exe
|
||||
@@ -0,0 +1,239 @@
|
||||
#include "displaytext.h"
|
||||
|
||||
#include <QMouseEvent>
|
||||
#include <QDateTime>
|
||||
#include <QTextCharFormat>
|
||||
#include <QTextCursor>
|
||||
#include <QTextBlock>
|
||||
#include <QMenu>
|
||||
#include <QAction>
|
||||
|
||||
#include "qt_helpers.hpp"
|
||||
|
||||
#include "moc_displaytext.cpp"
|
||||
|
||||
DisplayText::DisplayText(QWidget *parent)
|
||||
: QTextEdit(parent)
|
||||
, erase_action_ {new QAction {tr ("&Erase"), this}}
|
||||
{
|
||||
setReadOnly (true);
|
||||
viewport ()->setCursor (Qt::ArrowCursor);
|
||||
setWordWrapMode (QTextOption::NoWrap);
|
||||
|
||||
// max lines to limit heap usage
|
||||
document ()->setMaximumBlockCount (5000);
|
||||
|
||||
// context menu erase action
|
||||
setContextMenuPolicy (Qt::CustomContextMenu);
|
||||
connect (this, &DisplayText::customContextMenuRequested, [this] (QPoint const& position) {
|
||||
auto * menu = createStandardContextMenu (position);
|
||||
menu->addAction (erase_action_);
|
||||
menu->exec (mapToGlobal (position));
|
||||
delete menu;
|
||||
});
|
||||
connect (erase_action_, &QAction::triggered, this, &DisplayText::erase);
|
||||
}
|
||||
|
||||
void DisplayText::erase ()
|
||||
{
|
||||
clear ();
|
||||
Q_EMIT erased ();
|
||||
}
|
||||
|
||||
void DisplayText::setContentFont(QFont const& font)
|
||||
{
|
||||
char_font_ = font;
|
||||
selectAll ();
|
||||
auto cursor = textCursor ();
|
||||
cursor.beginEditBlock ();
|
||||
auto char_format = cursor.charFormat ();
|
||||
char_format.setFont (char_font_);
|
||||
cursor.mergeCharFormat (char_format);
|
||||
cursor.clearSelection ();
|
||||
cursor.movePosition (QTextCursor::End);
|
||||
|
||||
// position so viewport scrolled to left
|
||||
cursor.movePosition (QTextCursor::Up);
|
||||
cursor.movePosition (QTextCursor::StartOfLine);
|
||||
cursor.endEditBlock ();
|
||||
|
||||
setTextCursor (cursor);
|
||||
ensureCursorVisible ();
|
||||
}
|
||||
|
||||
void DisplayText::mouseDoubleClickEvent(QMouseEvent *e)
|
||||
{
|
||||
Q_EMIT selectCallsign(e->modifiers ());
|
||||
QTextEdit::mouseDoubleClickEvent(e);
|
||||
}
|
||||
|
||||
void DisplayText::insertLineSpacer(QString const& line)
|
||||
{
|
||||
appendText (line, "#d3d3d3");
|
||||
}
|
||||
|
||||
void DisplayText::appendText(QString const& text, QColor bg)
|
||||
{
|
||||
auto cursor = textCursor ();
|
||||
cursor.movePosition (QTextCursor::End);
|
||||
auto block_format = cursor.blockFormat ();
|
||||
block_format.setBackground (bg);
|
||||
if (0 == cursor.position ())
|
||||
{
|
||||
cursor.setBlockFormat (block_format);
|
||||
auto char_format = cursor.charFormat ();
|
||||
char_format.setFont (char_font_);
|
||||
cursor.setCharFormat (char_format);
|
||||
}
|
||||
else
|
||||
{
|
||||
cursor.insertBlock (block_format);
|
||||
}
|
||||
cursor.insertText (text);
|
||||
|
||||
// position so viewport scrolled to left
|
||||
cursor.movePosition (QTextCursor::StartOfLine);
|
||||
setTextCursor (cursor);
|
||||
ensureCursorVisible ();
|
||||
document ()->setMaximumBlockCount (document ()->maximumBlockCount ());
|
||||
}
|
||||
|
||||
|
||||
QString DisplayText::appendDXCCWorkedB4(QString message, QString const& callsign, QColor * bg,
|
||||
LogBook const& logBook, QColor color_CQ,
|
||||
QColor color_DXCC,
|
||||
QColor color_NewCall)
|
||||
{
|
||||
// allow for seconds
|
||||
int padding {message.indexOf (" ") > 4 ? 2 : 0};
|
||||
QString call = callsign;
|
||||
QString countryName;
|
||||
bool callWorkedBefore;
|
||||
bool countryWorkedBefore;
|
||||
|
||||
if(call.length()==2) {
|
||||
int i0=message.indexOf("CQ "+call);
|
||||
call=message.mid(i0+6,-1);
|
||||
i0=call.indexOf(" ");
|
||||
call=call.mid(0,i0);
|
||||
}
|
||||
if(call.length()<3) return message;
|
||||
if(!call.contains(QRegExp("[0-9]|[A-Z]"))) return message;
|
||||
|
||||
logBook.match(/*in*/call,/*out*/countryName,callWorkedBefore,countryWorkedBefore);
|
||||
|
||||
message = message.trimmed ();
|
||||
QString appendage;
|
||||
if (!countryWorkedBefore) // therefore not worked call either
|
||||
{
|
||||
appendage += "!";
|
||||
*bg = color_DXCC;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!callWorkedBefore) // but have worked the country
|
||||
{
|
||||
appendage += "~";
|
||||
*bg = color_NewCall;
|
||||
}
|
||||
else
|
||||
{
|
||||
appendage += " "; // have worked this call before
|
||||
*bg = color_CQ;
|
||||
}
|
||||
}
|
||||
|
||||
// do some obvious abbreviations
|
||||
countryName.replace ("Islands", "Is.");
|
||||
countryName.replace ("Island", "Is.");
|
||||
countryName.replace ("North ", "N. ");
|
||||
countryName.replace ("Northern ", "N. ");
|
||||
countryName.replace ("South ", "S. ");
|
||||
countryName.replace ("East ", "E. ");
|
||||
countryName.replace ("Eastern ", "E. ");
|
||||
countryName.replace ("West ", "W. ");
|
||||
countryName.replace ("Western ", "W. ");
|
||||
countryName.replace ("Central ", "C. ");
|
||||
countryName.replace (" and ", " & ");
|
||||
countryName.replace ("Republic", "Rep.");
|
||||
countryName.replace ("United States", "U.S.A.");
|
||||
countryName.replace ("Fed. Rep. of ", "");
|
||||
countryName.replace ("French ", "Fr.");
|
||||
countryName.replace ("Asiatic", "AS");
|
||||
countryName.replace ("European", "EU");
|
||||
countryName.replace ("African", "AF");
|
||||
|
||||
appendage += countryName;
|
||||
|
||||
// use a nbsp to save the start of appended text so we can find
|
||||
// it again later, align appended data at a fixed column if
|
||||
// there is space otherwise let it float to the right
|
||||
int space_count {40 + padding - message.size ()};
|
||||
if (space_count > 0)
|
||||
{
|
||||
message += QString {space_count, QChar {' '}};
|
||||
}
|
||||
message += QChar::Nbsp + appendage;
|
||||
|
||||
return message;
|
||||
}
|
||||
|
||||
void DisplayText::displayDecodedText(DecodedText const& decodedText, QString const& myCall,
|
||||
bool displayDXCCEntity, LogBook const& logBook,
|
||||
QColor color_CQ, QColor color_MyCall,
|
||||
QColor color_DXCC, QColor color_NewCall)
|
||||
{
|
||||
QColor bg {Qt::white};
|
||||
bool CQcall = false;
|
||||
if (decodedText.string ().contains (" CQ ")
|
||||
|| decodedText.string ().contains (" CQDX ")
|
||||
|| decodedText.string ().contains (" QRZ "))
|
||||
{
|
||||
CQcall = true;
|
||||
bg = color_CQ;
|
||||
}
|
||||
if (myCall != "" and (
|
||||
decodedText.indexOf (" " + myCall + " ") >= 0
|
||||
or decodedText.indexOf (" " + myCall + "/") >= 0
|
||||
or decodedText.indexOf ("/" + myCall + " ") >= 0
|
||||
or decodedText.indexOf ("<" + myCall + " ") >= 0
|
||||
or decodedText.indexOf (" " + myCall + ">") >= 0)) {
|
||||
bg = color_MyCall;
|
||||
}
|
||||
auto message = decodedText.string ();
|
||||
message = message.left (message.indexOf (QChar::Nbsp)); // strip appended info
|
||||
if (displayDXCCEntity && CQcall)
|
||||
// if enabled add the DXCC entity and B4 status to the end of the
|
||||
// preformated text line t1
|
||||
message = appendDXCCWorkedB4 (message, decodedText.CQersCall (), &bg, logBook, color_CQ,
|
||||
color_DXCC, color_NewCall);
|
||||
appendText (message.trimmed (), bg);
|
||||
}
|
||||
|
||||
|
||||
void DisplayText::displayTransmittedText(QString text, QString modeTx, qint32 txFreq,
|
||||
QColor color_TxMsg, bool bFastMode)
|
||||
{
|
||||
QString t1=" @ ";
|
||||
if(modeTx=="FT8") t1=" ~ ";
|
||||
if(modeTx=="JT4") t1=" $ ";
|
||||
if(modeTx=="JT65") t1=" # ";
|
||||
if(modeTx=="MSK144") t1=" & ";
|
||||
QString t2;
|
||||
t2.sprintf("%4d",txFreq);
|
||||
QString t;
|
||||
if(bFastMode or modeTx=="FT8") {
|
||||
t = QDateTime::currentDateTimeUtc().toString("hhmmss") + \
|
||||
" Tx " + t2 + t1 + text;
|
||||
} else {
|
||||
t = QDateTime::currentDateTimeUtc().toString("hhmm") + \
|
||||
" Tx " + t2 + t1 + text;
|
||||
}
|
||||
appendText (t, color_TxMsg);
|
||||
}
|
||||
|
||||
void DisplayText::displayQSY(QString text)
|
||||
{
|
||||
QString t = QDateTime::currentDateTimeUtc().toString("hhmmss") + " " + text;
|
||||
appendText (t, "hotpink");
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
subroutine demod64a(s3,nadd,afac1,mrsym,mrprob,mr2sym,mr2prob,ntest,nlow)
|
||||
|
||||
! Demodulate the 64-bin spectra for each of 63 symbols in a frame.
|
||||
|
||||
! Parameters
|
||||
! nadd number of spectra already summed
|
||||
! mrsym most reliable symbol value
|
||||
! mr2sym second most likely symbol value
|
||||
! mrprob probability that mrsym was the transmitted value
|
||||
! mr2prob probability that mr2sym was the transmitted value
|
||||
|
||||
implicit real*8 (a-h,o-z)
|
||||
real*4 s3(64,63),afac1
|
||||
integer mrsym(63),mrprob(63),mr2sym(63),mr2prob(63)
|
||||
|
||||
if(nadd.eq.-999) return
|
||||
afac=afac1 * float(nadd)**0.64
|
||||
scale=255.999
|
||||
|
||||
! Compute average spectral value
|
||||
ave=sum(s3)/(64.*63.)
|
||||
i1=1 !Silence warning
|
||||
i2=1
|
||||
|
||||
! Compute probabilities for most reliable symbol values
|
||||
do j=1,63
|
||||
s1=-1.e30
|
||||
psum=0.
|
||||
do i=1,64
|
||||
x=min(afac*s3(i,j)/ave,50.d0)
|
||||
psum=psum+s3(i,j)
|
||||
if(s3(i,j).gt.s1) then
|
||||
s1=s3(i,j)
|
||||
i1=i !Most reliable
|
||||
endif
|
||||
enddo
|
||||
if(psum.eq.0.0) psum=1.e-6
|
||||
|
||||
s2=-1.e30
|
||||
do i=1,64
|
||||
if(i.ne.i1 .and. s3(i,j).gt.s2) then
|
||||
s2=s3(i,j)
|
||||
i2=i !Second most reliable
|
||||
endif
|
||||
enddo
|
||||
p1=s1/psum !Symbol metrics for ftrsd
|
||||
p2=s2/psum
|
||||
mrsym(j)=i1-1
|
||||
mr2sym(j)=i2-1
|
||||
mrprob(j)=scale*p1
|
||||
mr2prob(j)=scale*p2
|
||||
enddo
|
||||
|
||||
nlow=0
|
||||
do j=1,63
|
||||
if(mrprob(j).le.5) nlow=nlow+1
|
||||
enddo
|
||||
ntest=sum(mrprob)
|
||||
|
||||
return
|
||||
end subroutine demod64a
|
||||
@@ -0,0 +1,160 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2007 Joel de Guzman
|
||||
Copyright (c) 2015 Kohei Takahashi
|
||||
|
||||
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_PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP
|
||||
#define BOOST_PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP
|
||||
|
||||
#include <boost/phoenix/core/limits.hpp>
|
||||
#include <boost/phoenix/support/iterate.hpp>
|
||||
#include <boost/phoenix/core/call.hpp>
|
||||
#include <boost/phoenix/core/expression.hpp>
|
||||
#include <boost/phoenix/core/meta_grammar.hpp>
|
||||
#include <boost/phoenix/core/detail/phx2_result.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
#ifndef BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
|
||||
# include <boost/mpl/if.hpp>
|
||||
# include <boost/type_traits/is_reference.hpp>
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
|
||||
# include <boost/phoenix/core/detail/cpp03/function_eval_expr.hpp>
|
||||
#else
|
||||
BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG(
|
||||
(boost)(phoenix)(detail)(function_eval)
|
||||
, (meta_grammar)(meta_grammar)
|
||||
, _
|
||||
)
|
||||
#endif
|
||||
|
||||
namespace boost { namespace phoenix {
|
||||
namespace detail
|
||||
{
|
||||
template <typename T>
|
||||
T& help_rvalue_deduction(T& x)
|
||||
{
|
||||
return x;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T const& help_rvalue_deduction(T const& x)
|
||||
{
|
||||
return x;
|
||||
}
|
||||
|
||||
struct function_eval
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
#ifdef BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
|
||||
template <typename This, typename F, typename Context>
|
||||
struct result<This(F, Context)>
|
||||
{
|
||||
typedef typename
|
||||
remove_reference<
|
||||
typename boost::result_of<evaluator(F, Context)>::type
|
||||
>::type
|
||||
fn;
|
||||
|
||||
typedef typename boost::result_of<fn()>::type type;
|
||||
};
|
||||
|
||||
template <typename F, typename Context>
|
||||
typename result<function_eval(F const&, Context const&)>::type
|
||||
operator()(F const & f, Context const & ctx) const
|
||||
{
|
||||
return boost::phoenix::eval(f, ctx)();
|
||||
}
|
||||
|
||||
template <typename F, typename Context>
|
||||
typename result<function_eval(F &, Context const&)>::type
|
||||
operator()(F & f, Context const & ctx) const
|
||||
{
|
||||
return boost::phoenix::eval(f, ctx)();
|
||||
}
|
||||
|
||||
#include <boost/phoenix/core/detail/cpp03/function_eval.hpp>
|
||||
#else
|
||||
template <typename, typename, typename...> struct result_impl;
|
||||
|
||||
template <typename F, typename... A, typename Head, typename... Tail>
|
||||
struct result_impl<F, void(A...), Head, Tail...>
|
||||
: result_impl<F, void(A..., Head), Tail...>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename F, typename... A, typename Context>
|
||||
struct result_impl<F, void(A...), Context>
|
||||
{
|
||||
typedef typename
|
||||
remove_reference<
|
||||
typename boost::result_of<evaluator(F, Context)>::type
|
||||
>::type
|
||||
fn;
|
||||
|
||||
template <typename T>
|
||||
struct result_of_evaluator
|
||||
{
|
||||
typedef typename boost::add_reference<
|
||||
typename boost::add_const<
|
||||
typename boost::result_of<
|
||||
boost::phoenix::evaluator(T, Context)
|
||||
>::type
|
||||
>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
typedef typename
|
||||
boost::result_of<
|
||||
fn(typename result_of_evaluator<A>::type...)
|
||||
>::type
|
||||
type;
|
||||
|
||||
static type call(F f, A... a, Context ctx)
|
||||
{
|
||||
return boost::phoenix::eval(f, ctx)(help_rvalue_deduction(boost::phoenix::eval(a, ctx))...);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename This, typename F, typename... A>
|
||||
struct result<This(F, A...)>
|
||||
: result_impl<F, void(), A...>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename F, typename... A>
|
||||
typename result<
|
||||
function_eval(
|
||||
F const &
|
||||
, typename mpl::if_<is_reference<A>, A, A const &>::type...
|
||||
)
|
||||
>::type
|
||||
// 'A &... a, Context const &ctx' doesn't work as intended: type deduction always fail.
|
||||
operator()(F && f, A &&... a) const
|
||||
{
|
||||
return
|
||||
result<
|
||||
function_eval(
|
||||
typename mpl::if_<is_reference<F>, F, F const &>::type
|
||||
, typename mpl::if_<is_reference<A>, A, A const &>::type...
|
||||
)
|
||||
>::call(f, a...);
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <typename Dummy>
|
||||
struct default_actions::when<detail::rule::function_eval, Dummy>
|
||||
: phoenix::call<detail::function_eval>
|
||||
{};
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,229 @@
|
||||
//
|
||||
// Copyright (c) 2000-2010
|
||||
// Joerg Walter, Mathias Koch, David Bellot
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
// The authors gratefully acknowledge the support of
|
||||
// GeNeSys mbH & Co. KG in producing this work.
|
||||
//
|
||||
|
||||
/// \file fwd.hpp is essentially used to forward declare the main types
|
||||
|
||||
#ifndef BOOST_UBLAS_FWD_H
|
||||
#define BOOST_UBLAS_FWD_H
|
||||
|
||||
#include <memory>
|
||||
|
||||
#ifdef BOOST_UBLAS_CPP_GE_2011
|
||||
#include <array>
|
||||
#endif
|
||||
|
||||
namespace boost { namespace numeric { namespace ublas {
|
||||
|
||||
// Storage types
|
||||
template<class T, class ALLOC = std::allocator<T> >
|
||||
class unbounded_array;
|
||||
|
||||
template<class T, std::size_t N, class ALLOC = std::allocator<T> >
|
||||
class bounded_array;
|
||||
|
||||
template <class Z = std::size_t, class D = std::ptrdiff_t>
|
||||
class basic_range;
|
||||
template <class Z = std::size_t, class D = std::ptrdiff_t>
|
||||
class basic_slice;
|
||||
typedef basic_range<> range;
|
||||
typedef basic_slice<> slice;
|
||||
template<class A = unbounded_array<std::size_t> >
|
||||
class indirect_array;
|
||||
|
||||
template<class I, class T, class ALLOC = std::allocator<std::pair<const I, T> > >
|
||||
class map_std;
|
||||
template<class I, class T, class ALLOC = std::allocator<std::pair<I, T> > >
|
||||
class map_array;
|
||||
|
||||
// Expression types
|
||||
struct scalar_tag {};
|
||||
|
||||
struct vector_tag {};
|
||||
template<class E>
|
||||
class vector_expression;
|
||||
template<class C>
|
||||
class vector_container;
|
||||
|
||||
template<class E>
|
||||
class vector_reference;
|
||||
|
||||
struct matrix_tag {};
|
||||
|
||||
template<class E>
|
||||
class matrix_expression;
|
||||
template<class C>
|
||||
class matrix_container;
|
||||
|
||||
template<class E>
|
||||
class matrix_reference;
|
||||
|
||||
template<class V>
|
||||
class vector_range;
|
||||
template<class V>
|
||||
class vector_slice;
|
||||
template<class V, class IA = indirect_array<> >
|
||||
class vector_indirect;
|
||||
|
||||
template<class M>
|
||||
class matrix_row;
|
||||
template<class M>
|
||||
class matrix_column;
|
||||
template<class M>
|
||||
class matrix_vector_range;
|
||||
template<class M>
|
||||
class matrix_vector_slice;
|
||||
template<class M, class IA = indirect_array<> >
|
||||
class matrix_vector_indirect;
|
||||
template<class M>
|
||||
class matrix_range;
|
||||
template<class M>
|
||||
class matrix_slice;
|
||||
template<class M, class IA = indirect_array<> >
|
||||
class matrix_indirect;
|
||||
|
||||
template<class T, class A = unbounded_array<T> >
|
||||
class vector;
|
||||
#ifdef BOOST_UBLAS_CPP_GE_2011
|
||||
template<class T, std::size_t N, class A = std::array<T, N> >
|
||||
class fixed_vector;
|
||||
#endif
|
||||
template<class T, std::size_t N>
|
||||
class bounded_vector;
|
||||
|
||||
template<class T = int, class ALLOC = std::allocator<T> >
|
||||
class unit_vector;
|
||||
template<class T = int, class ALLOC = std::allocator<T> >
|
||||
class zero_vector;
|
||||
template<class T = int, class ALLOC = std::allocator<T> >
|
||||
class scalar_vector;
|
||||
|
||||
template<class T, std::size_t N>
|
||||
class c_vector;
|
||||
|
||||
// Sparse vectors
|
||||
template<class T, class A = map_std<std::size_t, T> >
|
||||
class mapped_vector;
|
||||
template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
|
||||
class compressed_vector;
|
||||
template<class T, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
|
||||
class coordinate_vector;
|
||||
|
||||
// Matrix orientation type
|
||||
struct unknown_orientation_tag {};
|
||||
struct row_major_tag {};
|
||||
struct column_major_tag {};
|
||||
|
||||
// Matrix storage layout parameterisation
|
||||
template <class Z = std::size_t, class D = std::ptrdiff_t>
|
||||
struct basic_row_major;
|
||||
typedef basic_row_major<> row_major;
|
||||
|
||||
template <class Z = std::size_t, class D = std::ptrdiff_t>
|
||||
struct basic_column_major;
|
||||
typedef basic_column_major<> column_major;
|
||||
|
||||
template<class T, class L = row_major, class A = unbounded_array<T> >
|
||||
class matrix;
|
||||
#ifdef BOOST_UBLAS_CPP_GE_2011
|
||||
template<class T, std::size_t M, std::size_t N, class L = row_major, class A = std::array<T, M*N> >
|
||||
class fixed_matrix;
|
||||
#endif
|
||||
template<class T, std::size_t M, std::size_t N, class L = row_major>
|
||||
class bounded_matrix;
|
||||
|
||||
template<class T = int, class ALLOC = std::allocator<T> >
|
||||
class identity_matrix;
|
||||
template<class T = int, class ALLOC = std::allocator<T> >
|
||||
class zero_matrix;
|
||||
template<class T = int, class ALLOC = std::allocator<T> >
|
||||
class scalar_matrix;
|
||||
|
||||
template<class T, std::size_t M, std::size_t N>
|
||||
class c_matrix;
|
||||
|
||||
template<class T, class L = row_major, class A = unbounded_array<unbounded_array<T> > >
|
||||
class vector_of_vector;
|
||||
|
||||
template<class T, class L = row_major, class A = vector<compressed_vector<T> > >
|
||||
class generalized_vector_of_vector;
|
||||
|
||||
// Triangular matrix type
|
||||
struct lower_tag {};
|
||||
struct upper_tag {};
|
||||
struct unit_lower_tag : public lower_tag {};
|
||||
struct unit_upper_tag : public upper_tag {};
|
||||
struct strict_lower_tag : public lower_tag {};
|
||||
struct strict_upper_tag : public upper_tag {};
|
||||
|
||||
// Triangular matrix parameterisation
|
||||
template <class Z = std::size_t>
|
||||
struct basic_full;
|
||||
typedef basic_full<> full;
|
||||
|
||||
template <class Z = std::size_t>
|
||||
struct basic_lower;
|
||||
typedef basic_lower<> lower;
|
||||
|
||||
template <class Z = std::size_t>
|
||||
struct basic_upper;
|
||||
typedef basic_upper<> upper;
|
||||
|
||||
template <class Z = std::size_t>
|
||||
struct basic_unit_lower;
|
||||
typedef basic_unit_lower<> unit_lower;
|
||||
|
||||
template <class Z = std::size_t>
|
||||
struct basic_unit_upper;
|
||||
typedef basic_unit_upper<> unit_upper;
|
||||
|
||||
template <class Z = std::size_t>
|
||||
struct basic_strict_lower;
|
||||
typedef basic_strict_lower<> strict_lower;
|
||||
|
||||
template <class Z = std::size_t>
|
||||
struct basic_strict_upper;
|
||||
typedef basic_strict_upper<> strict_upper;
|
||||
|
||||
// Special matrices
|
||||
template<class T, class L = row_major, class A = unbounded_array<T> >
|
||||
class banded_matrix;
|
||||
template<class T, class L = row_major, class A = unbounded_array<T> >
|
||||
class diagonal_matrix;
|
||||
|
||||
template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
|
||||
class triangular_matrix;
|
||||
template<class M, class TRI = lower>
|
||||
class triangular_adaptor;
|
||||
|
||||
template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
|
||||
class symmetric_matrix;
|
||||
template<class M, class TRI = lower>
|
||||
class symmetric_adaptor;
|
||||
|
||||
template<class T, class TRI = lower, class L = row_major, class A = unbounded_array<T> >
|
||||
class hermitian_matrix;
|
||||
template<class M, class TRI = lower>
|
||||
class hermitian_adaptor;
|
||||
|
||||
// Sparse matrices
|
||||
template<class T, class L = row_major, class A = map_std<std::size_t, T> >
|
||||
class mapped_matrix;
|
||||
template<class T, class L = row_major, class A = map_std<std::size_t, map_std<std::size_t, T> > >
|
||||
class mapped_vector_of_mapped_vector;
|
||||
template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
|
||||
class compressed_matrix;
|
||||
template<class T, class L = row_major, std::size_t IB = 0, class IA = unbounded_array<std::size_t>, class TA = unbounded_array<T> >
|
||||
class coordinate_matrix;
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,69 @@
|
||||
/* Boost interval/arith3.hpp template implementation file
|
||||
*
|
||||
* This headers provides arithmetical functions
|
||||
* which compute an interval given some base
|
||||
* numbers. The resulting interval encloses the
|
||||
* real result of the arithmetic operation.
|
||||
*
|
||||
* Copyright 2003 Guillaume Melquiond
|
||||
*
|
||||
* 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_INTERVAL_ARITH3_HPP
|
||||
#define BOOST_NUMERIC_INTERVAL_ARITH3_HPP
|
||||
|
||||
#include <boost/numeric/interval/detail/interval_prototype.hpp>
|
||||
#include <boost/numeric/interval/detail/test_input.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace interval_lib {
|
||||
|
||||
template<class I> inline
|
||||
I add(const typename I::base_type& x, const typename I::base_type& y)
|
||||
{
|
||||
typedef typename I::traits_type Policies;
|
||||
if (detail::test_input<typename I::base_type, Policies>(x, y))
|
||||
return I::empty();
|
||||
typename Policies::rounding rnd;
|
||||
return I(rnd.add_down(x, y), rnd.add_up(x, y), true);
|
||||
}
|
||||
|
||||
template<class I> inline
|
||||
I sub(const typename I::base_type& x, const typename I::base_type& y)
|
||||
{
|
||||
typedef typename I::traits_type Policies;
|
||||
if (detail::test_input<typename I::base_type, Policies>(x, y))
|
||||
return I::empty();
|
||||
typename Policies::rounding rnd;
|
||||
return I(rnd.sub_down(x, y), rnd.sub_up(x, y), true);
|
||||
}
|
||||
|
||||
template<class I> inline
|
||||
I mul(const typename I::base_type& x, const typename I::base_type& y)
|
||||
{
|
||||
typedef typename I::traits_type Policies;
|
||||
if (detail::test_input<typename I::base_type, Policies>(x, y))
|
||||
return I::empty();
|
||||
typename Policies::rounding rnd;
|
||||
return I(rnd.mul_down(x, y), rnd.mul_up(x, y), true);
|
||||
}
|
||||
|
||||
template<class I> inline
|
||||
I div(const typename I::base_type& x, const typename I::base_type& y)
|
||||
{
|
||||
typedef typename I::traits_type Policies;
|
||||
if (detail::test_input<typename I::base_type, Policies>(x, y) || user::is_zero(y))
|
||||
return I::empty();
|
||||
typename Policies::rounding rnd;
|
||||
return I(rnd.div_down(x, y), rnd.div_up(x, y), true);
|
||||
}
|
||||
|
||||
} // namespace interval_lib
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_NUMERIC_INTERVAL_ARITH3_HPP
|
||||
@@ -0,0 +1,44 @@
|
||||
// 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 FUNCTION_HANDLE_DWA2002725_HPP
|
||||
# define FUNCTION_HANDLE_DWA2002725_HPP
|
||||
# include <boost/python/handle.hpp>
|
||||
# include <boost/python/detail/caller.hpp>
|
||||
# include <boost/python/default_call_policies.hpp>
|
||||
# include <boost/python/object/py_function.hpp>
|
||||
# include <boost/python/signature.hpp>
|
||||
|
||||
namespace boost { namespace python { namespace objects {
|
||||
|
||||
BOOST_PYTHON_DECL handle<> function_handle_impl(py_function const& f);
|
||||
|
||||
// Just like function_object, but returns a handle<> instead. Using
|
||||
// this for arg_to_python<> allows us to break a circular dependency
|
||||
// between object and arg_to_python.
|
||||
template <class F, class Signature>
|
||||
inline handle<> function_handle(F const& f, Signature)
|
||||
{
|
||||
enum { n_arguments = mpl::size<Signature>::value - 1 };
|
||||
|
||||
return objects::function_handle_impl(
|
||||
python::detail::caller<
|
||||
F,default_call_policies,Signature
|
||||
>(
|
||||
f, default_call_policies()
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// Just like make_function, but returns a handle<> intead. Same
|
||||
// reasoning as above.
|
||||
template <class F>
|
||||
handle<> make_function_handle(F f)
|
||||
{
|
||||
return objects::function_handle(f, python::detail::get_signature(f));
|
||||
}
|
||||
|
||||
}}} // namespace boost::python::objects
|
||||
|
||||
#endif // FUNCTION_HANDLE_DWA2002725_HPP
|
||||
@@ -0,0 +1,52 @@
|
||||
|
||||
#ifndef BOOST_MPL_AT_HPP_INCLUDED
|
||||
#define BOOST_MPL_AT_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$
|
||||
|
||||
#include <boost/mpl/at_fwd.hpp>
|
||||
#include <boost/mpl/aux_/at_impl.hpp>
|
||||
#include <boost/mpl/long.hpp>
|
||||
#include <boost/mpl/sequence_tag.hpp>
|
||||
#include <boost/mpl/aux_/na_spec.hpp>
|
||||
#include <boost/mpl/aux_/lambda_support.hpp>
|
||||
#include <boost/mpl/aux_/nttp_decl.hpp>
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename BOOST_MPL_AUX_NA_PARAM(Sequence)
|
||||
, typename BOOST_MPL_AUX_NA_PARAM(N)
|
||||
>
|
||||
struct at
|
||||
: at_impl< typename sequence_tag<Sequence>::type >
|
||||
::template apply< Sequence,N >
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,at,(Sequence,N))
|
||||
};
|
||||
|
||||
template<
|
||||
typename Sequence
|
||||
, BOOST_MPL_AUX_NTTP_DECL(long, N)
|
||||
>
|
||||
struct at_c
|
||||
: at_impl< typename sequence_tag<Sequence>::type >
|
||||
::template apply< Sequence,mpl::long_<N> >
|
||||
{
|
||||
};
|
||||
|
||||
BOOST_MPL_AUX_NA_SPEC(2, at)
|
||||
|
||||
}}
|
||||
|
||||
#endif // BOOST_MPL_AT_HPP_INCLUDED
|
||||
@@ -0,0 +1,265 @@
|
||||
//
|
||||
// Copyright (c) Antony Polukhin, 2012-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)
|
||||
//
|
||||
|
||||
#ifndef BOOST_TYPE_INDEX_HPP
|
||||
#define BOOST_TYPE_INDEX_HPP
|
||||
|
||||
/// \file boost/type_index.hpp
|
||||
/// \brief Includes minimal set of headers required to use the Boost.TypeIndex library.
|
||||
///
|
||||
/// By inclusion of this file most optimal type index classes will be included and used
|
||||
/// as a boost::typeindex::type_index and boost::typeindex::type_info.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
|
||||
# include BOOST_TYPE_INDEX_USER_TYPEINDEX
|
||||
# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
|
||||
# pragma detect_mismatch( "boost__type_index__abi", "user defined type_index class is used: " BOOST_STRINGIZE(BOOST_TYPE_INDEX_USER_TYPEINDEX))
|
||||
# endif
|
||||
#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
|
||||
# include <boost/type_index/stl_type_index.hpp>
|
||||
# if defined(BOOST_NO_RTTI) || defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)
|
||||
# include <boost/type_index/detail/stl_register_class.hpp>
|
||||
# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
|
||||
# pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - typeid() is used only for templates")
|
||||
# endif
|
||||
# else
|
||||
# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
|
||||
# pragma detect_mismatch( "boost__type_index__abi", "RTTI is used")
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
# include <boost/type_index/ctti_type_index.hpp>
|
||||
# include <boost/type_index/detail/ctti_register_class.hpp>
|
||||
# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
|
||||
# pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - using CTTI")
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_TYPE_INDEX_REGISTER_CLASS
|
||||
#define BOOST_TYPE_INDEX_REGISTER_CLASS
|
||||
#endif
|
||||
|
||||
namespace boost { namespace typeindex {
|
||||
|
||||
#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
|
||||
|
||||
/// \def BOOST_TYPE_INDEX_FUNCTION_SIGNATURE
|
||||
/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is used by boost::typeindex::ctti_type_index class to
|
||||
/// deduce the name of a type. If your compiler is not recognized
|
||||
/// by the TypeIndex library and you wish to work with boost::typeindex::ctti_type_index, you may
|
||||
/// define this macro by yourself.
|
||||
///
|
||||
/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE must be defined to a compiler specific macro
|
||||
/// that outputs the \b whole function signature \b including \b template \b parameters.
|
||||
///
|
||||
/// If your compiler is not recognised and BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is not defined,
|
||||
/// then a compile-time error will arise at any attempt to use boost::typeindex::ctti_type_index classes.
|
||||
///
|
||||
/// See BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS and BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
|
||||
/// for an information of how to tune the implementation to make a nice pretty_name() output.
|
||||
#define BOOST_TYPE_INDEX_FUNCTION_SIGNATURE BOOST_CURRENT_FUNCTION
|
||||
|
||||
/// \def BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
|
||||
/// This is a helper macro for making correct pretty_names() with RTTI off.
|
||||
///
|
||||
/// BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING macro may be defined to
|
||||
/// '(begin_skip, end_skip, runtime_skip, runtime_skip_until)' with parameters for adding a
|
||||
/// support for compilers, that by default are not recognized by TypeIndex library.
|
||||
///
|
||||
/// \b Example:
|
||||
///
|
||||
/// Imagine the situation when
|
||||
/// \code boost::typeindex::ctti_type_index::type_id<int>().pretty_name() \endcode
|
||||
/// returns the following string:
|
||||
/// \code "static const char *boost::detail::ctti<int>::n() [T = int]" \endcode
|
||||
/// and \code boost::typeindex::ctti_type_index::type_id<short>().pretty_name() \endcode returns the following:
|
||||
/// \code "static const char *boost::detail::ctti<short>::n() [T = short]" \endcode
|
||||
///
|
||||
/// As we may see first 39 characters are "static const char *boost::detail::ctti<" and they do not depend on
|
||||
/// the type T. After first 39 characters we have a human readable type name which is duplicated at the end
|
||||
/// of a string. String always ends on ']', which consumes 1 character.
|
||||
///
|
||||
/// Now if we define `BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING` to
|
||||
/// `(39, 1, false, "")` we'll be getting \code "int>::n() [T = int" \endcode
|
||||
/// for `boost::typeindex::ctti_type_index::type_id<int>().pretty_name()` and \code "short>::n() [T = short" \endcode
|
||||
/// for `boost::typeindex::ctti_type_index::type_id<short>().pretty_name()`.
|
||||
///
|
||||
/// Now we need to take additional care of the characters that go before the last mention of our type. We'll
|
||||
/// do that by telling the macro that we need to cut off everything that goes before the "T = " including the "T = "
|
||||
/// itself:
|
||||
///
|
||||
/// \code (39, 1, true, "T = ") \endcode
|
||||
///
|
||||
/// In case of GCC or Clang command line we need to add the following line while compiling all the sources:
|
||||
///
|
||||
/// \code
|
||||
/// -DBOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING='(39, 1, true, "T = ")'
|
||||
/// \endcode
|
||||
/// \param begin_skip How many characters must be skipped at the beginning of the type holding string.
|
||||
/// Must be a compile time constant.
|
||||
/// \param end_skip How many characters must be skipped at the end of the type holding string.
|
||||
/// Must be a compile time constant.
|
||||
/// \param runtime_skip Do we need additional checks at runtime to cut off the more characters.
|
||||
/// Must be `true` or `false`.
|
||||
/// \param runtime_skip_until Skip all the characters before the following string (including the string itself).
|
||||
/// Must be a compile time array of characters.
|
||||
///
|
||||
/// See [RTTI emulation limitations](boost_typeindex/rtti_emulation_limitations.html) for more info.
|
||||
#define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING (0, 0, false, "")
|
||||
|
||||
|
||||
/// Depending on a compiler flags, optimal implementation of type_index will be used
|
||||
/// as a default boost::typeindex::type_index.
|
||||
///
|
||||
/// Could be a boost::typeindex::stl_type_index, boost::typeindex::ctti_type_index or
|
||||
/// user defined type_index class.
|
||||
///
|
||||
/// \b See boost::typeindex::type_index_facade for a full description of type_index functions.
|
||||
typedef platform_specific type_index;
|
||||
#elif defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
|
||||
// Nothing to do
|
||||
#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
|
||||
typedef boost::typeindex::stl_type_index type_index;
|
||||
#else
|
||||
typedef boost::typeindex::ctti_type_index type_index;
|
||||
#endif
|
||||
|
||||
/// Depending on a compiler flags, optimal implementation of type_info will be used
|
||||
/// as a default boost::typeindex::type_info.
|
||||
///
|
||||
/// Could be a std::type_info, boost::typeindex::detail::ctti_data or
|
||||
/// some user defined class.
|
||||
///
|
||||
/// type_info \b is \b not copyable or default constructible. It is \b not assignable too!
|
||||
typedef type_index::type_info_t type_info;
|
||||
|
||||
#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
|
||||
|
||||
/// \def BOOST_TYPE_INDEX_USER_TYPEINDEX
|
||||
/// BOOST_TYPE_INDEX_USER_TYPEINDEX can be defined to the path to header file
|
||||
/// with user provided implementation of type_index.
|
||||
///
|
||||
/// See [Making a custom type_index](boost_typeindex/making_a_custom_type_index.html) section
|
||||
/// of documentation for usage example.
|
||||
#define BOOST_TYPE_INDEX_USER_TYPEINDEX <full/absolute/path/to/header/with/type_index.hpp>
|
||||
|
||||
|
||||
/// \def BOOST_TYPE_INDEX_REGISTER_CLASS
|
||||
/// BOOST_TYPE_INDEX_REGISTER_CLASS is used to help to emulate RTTI.
|
||||
/// Put this macro into the public section of polymorphic class to allow runtime type detection.
|
||||
///
|
||||
/// Depending on the typeid() availability this macro will expand to nothing or to virtual helper function
|
||||
/// `virtual const type_info& boost_type_info_type_id_runtime_() const noexcept`.
|
||||
///
|
||||
/// \b Example:
|
||||
/// \code
|
||||
/// class A {
|
||||
/// public:
|
||||
/// BOOST_TYPE_INDEX_REGISTER_CLASS
|
||||
/// virtual ~A(){}
|
||||
/// };
|
||||
///
|
||||
/// struct B: public A {
|
||||
/// BOOST_TYPE_INDEX_REGISTER_CLASS
|
||||
/// };
|
||||
///
|
||||
/// struct C: public B {
|
||||
/// BOOST_TYPE_INDEX_REGISTER_CLASS
|
||||
/// };
|
||||
///
|
||||
/// ...
|
||||
///
|
||||
/// C c1;
|
||||
/// A* pc1 = &c1;
|
||||
/// assert(boost::typeindex::type_id<C>() == boost::typeindex::type_id_runtime(*pc1));
|
||||
/// \endcode
|
||||
#define BOOST_TYPE_INDEX_REGISTER_CLASS nothing-or-some-virtual-functions
|
||||
|
||||
/// \def BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
|
||||
/// BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY is a helper macro that must be defined if mixing
|
||||
/// RTTI on/off modules. See
|
||||
/// [Mixing sources with RTTI on and RTTI off](boost_typeindex/mixing_sources_with_rtti_on_and_.html)
|
||||
/// section of documentation for more info.
|
||||
#define BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
|
||||
|
||||
#endif // defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
|
||||
|
||||
|
||||
/// Function to get boost::typeindex::type_index for a type T.
|
||||
/// Removes const, volatile && and & modifiers from T.
|
||||
///
|
||||
/// \b Example:
|
||||
/// \code
|
||||
/// type_index ti = type_id<int&>();
|
||||
/// std::cout << ti.pretty_name(); // Outputs 'int'
|
||||
/// \endcode
|
||||
///
|
||||
/// \tparam T Type for which type_index must be created.
|
||||
/// \throw Nothing.
|
||||
/// \return boost::typeindex::type_index with information about the specified type T.
|
||||
template <class T>
|
||||
inline type_index type_id() BOOST_NOEXCEPT {
|
||||
return type_index::type_id<T>();
|
||||
}
|
||||
|
||||
/// Function for constructing boost::typeindex::type_index instance for type T.
|
||||
/// Does not remove const, volatile, & and && modifiers from T.
|
||||
///
|
||||
/// If T has no const, volatile, & and && modifiers, then returns exactly
|
||||
/// the same result as in case of calling `type_id<T>()`.
|
||||
///
|
||||
/// \b Example:
|
||||
/// \code
|
||||
/// type_index ti = type_id_with_cvr<int&>();
|
||||
/// std::cout << ti.pretty_name(); // Outputs 'int&'
|
||||
/// \endcode
|
||||
///
|
||||
/// \tparam T Type for which type_index must be created.
|
||||
/// \throw Nothing.
|
||||
/// \return boost::typeindex::type_index with information about the specified type T.
|
||||
template <class T>
|
||||
inline type_index type_id_with_cvr() BOOST_NOEXCEPT {
|
||||
return type_index::type_id_with_cvr<T>();
|
||||
}
|
||||
|
||||
/// Function that works exactly like C++ typeid(rtti_val) call, but returns boost::type_index.
|
||||
///
|
||||
/// Returns runtime information about specified type.
|
||||
///
|
||||
/// \b Requirements: RTTI available or Base and Derived classes must be marked with BOOST_TYPE_INDEX_REGISTER_CLASS.
|
||||
///
|
||||
/// \b Example:
|
||||
/// \code
|
||||
/// struct Base { virtual ~Base(){} };
|
||||
/// struct Derived: public Base {};
|
||||
/// ...
|
||||
/// Derived d;
|
||||
/// Base& b = d;
|
||||
/// type_index ti = type_id_runtime(b);
|
||||
/// std::cout << ti.pretty_name(); // Outputs 'Derived'
|
||||
/// \endcode
|
||||
///
|
||||
/// \param runtime_val Variable which runtime type must be returned.
|
||||
/// \throw Nothing.
|
||||
/// \return boost::typeindex::type_index with information about the specified variable.
|
||||
template <class T>
|
||||
inline type_index type_id_runtime(const T& runtime_val) BOOST_NOEXCEPT {
|
||||
return type_index::type_id_runtime(runtime_val);
|
||||
}
|
||||
|
||||
}} // namespace boost::typeindex
|
||||
|
||||
|
||||
|
||||
#endif // BOOST_TYPE_INDEX_HPP
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
// Status=review
|
||||
.Receiver Noise Level
|
||||
|
||||
- If it is not already highlighted in green, click the *Monitor*
|
||||
button to start normal receive operation.
|
||||
|
||||
- Be sure your transceiver is set to *USB* (or *USB Data*) mode.
|
||||
|
||||
- Use the receiver gain controls and/or the computer's audio mixer
|
||||
controls to set the background noise level (scale at lower left of
|
||||
main window) to around 30 dB when no signals are present. It is
|
||||
usually best to turn AGC off or reduce the RF gain control to minimize
|
||||
AGC action.
|
||||
|
||||
.Bandwidth and Frequency Setting
|
||||
|
||||
- If your transceiver offers more than one bandwidth setting in USB
|
||||
mode, it may be advantageous to choose the widest one possible, up to
|
||||
about 5 kHz. This choice has the desirable effect of allowing the
|
||||
*Wide Graph* (waterfall and 2D spectrum) to display the conventional
|
||||
JT65 and JT9 sub-bands simultaneously on most HF bands. Further
|
||||
details are provided in the <<TUTORIAL,Basic Operating Tutorial>>. A
|
||||
wider displayed bandwidth may also be helpful at VHF and above, where
|
||||
JT4, JT65, and QRA64 signals are found over much wider ranges of
|
||||
frequencies.
|
||||
|
||||
- If you have only a standard SSB filter you won’t be able to display
|
||||
more than about 2.7 kHz bandwidth. Depending on the exact dial
|
||||
frequency setting, on HF bands you can display the full sub-band
|
||||
generally used for one mode (JT65 or JT9) and part of the sub-band for
|
||||
the other mode.
|
||||
|
||||
- Of course, you might prefer to concentrate on one mode at a time,
|
||||
setting your dial frequency to (say) 14.074 for FT8, 14.076 for JT65,
|
||||
or 14.078 for JT9. Present conventions have the nominal JT9 dial
|
||||
frequency 2 kHz higher than the JT65 dial frequency on most bands, and
|
||||
the FT8 frequency 2 kHz lower.
|
||||
|
||||
.Transmitter Audio Level
|
||||
|
||||
* Click the *Tune* button on the main screen to switch the
|
||||
radio into transmit mode and generate a steady audio tone.
|
||||
|
||||
* Listen to the generated audio tone using your radio’s *Monitor*
|
||||
facility. The transmitted tone should be perfectly smooth, with no
|
||||
clicks or glitches. Make sure that this is true even when you
|
||||
simultaneously use the computer to do other tasks such as email, web
|
||||
browsing, etc.
|
||||
|
||||
* Adjust the *Pwr" slider (at the right edge of the main window)
|
||||
downward from its maximum until the RF output from your transmitter
|
||||
falls slightly. This is generally a good level for audio drive.
|
||||
|
||||
* Toggle the *Tune* button once more or click *Halt Tx* to stop your
|
||||
test transmission.
|
||||
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
* 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)
|
||||
*
|
||||
* Copyright (c) 2009 Helge Bahmann
|
||||
* Copyright (c) 2013 Tim Blechmann
|
||||
* Copyright (c) 2012 - 2014 Andrey Semashev
|
||||
*/
|
||||
/*!
|
||||
* \file atomic/detail/caps_msvc_arm.hpp
|
||||
*
|
||||
* This header defines feature capabilities macros
|
||||
*/
|
||||
|
||||
#ifndef BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
|
||||
#define BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
|
||||
|
||||
#include <boost/atomic/detail/config.hpp>
|
||||
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
|
||||
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
|
||||
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
|
||||
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
|
||||
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
|
||||
|
||||
#define BOOST_ATOMIC_THREAD_FENCE 2
|
||||
#define BOOST_ATOMIC_SIGNAL_FENCE 2
|
||||
|
||||
#endif // BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
|
||||
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user