Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,588 @@
|
||||
/* Copyright 2003-2013 Joaquin M Lopez Munoz.
|
||||
* 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/multi_index for library home page.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
|
||||
#define BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
/* Safe mode machinery, in the spirit of Cay Hortmann's "Safe STL"
|
||||
* (http://www.horstmann.com/safestl.html).
|
||||
* In this mode, containers of type Container are derived from
|
||||
* safe_container<Container>, and their corresponding iterators
|
||||
* are wrapped with safe_iterator. These classes provide
|
||||
* an internal record of which iterators are at a given moment associated
|
||||
* to a given container, and properly mark the iterators as invalid
|
||||
* when the container gets destroyed.
|
||||
* Iterators are chained in a single attached list, whose header is
|
||||
* kept by the container. More elaborate data structures would yield better
|
||||
* performance, but I decided to keep complexity to a minimum since
|
||||
* speed is not an issue here.
|
||||
* Safe mode iterators automatically check that only proper operations
|
||||
* are performed on them: for instance, an invalid iterator cannot be
|
||||
* dereferenced. Additionally, a set of utilty macros and functions are
|
||||
* provided that serve to implement preconditions and cooperate with
|
||||
* the framework within the container.
|
||||
* Iterators can also be unchecked, i.e. they do not have info about
|
||||
* which container they belong in. This situation arises when the iterator
|
||||
* is restored from a serialization archive: only information on the node
|
||||
* is available, and it is not possible to determine to which container
|
||||
* the iterator is associated to. The only sensible policy is to assume
|
||||
* unchecked iterators are valid, though this can certainly generate false
|
||||
* positive safe mode checks.
|
||||
* This is not a full-fledged safe mode framework, and is only intended
|
||||
* for use within the limits of Boost.MultiIndex.
|
||||
*/
|
||||
|
||||
/* Assertion macros. These resolve to no-ops if
|
||||
* !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE).
|
||||
*/
|
||||
|
||||
#if !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
|
||||
#undef BOOST_MULTI_INDEX_SAFE_MODE_ASSERT
|
||||
#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) ((void)0)
|
||||
#else
|
||||
#if !defined(BOOST_MULTI_INDEX_SAFE_MODE_ASSERT)
|
||||
#include <boost/assert.hpp>
|
||||
#define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) BOOST_ASSERT(expr)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_valid_iterator(it), \
|
||||
safe_mode::invalid_iterator);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(it) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_dereferenceable_iterator(it), \
|
||||
safe_mode::not_dereferenceable_iterator);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(it) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_incrementable_iterator(it), \
|
||||
safe_mode::not_incrementable_iterator);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(it) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_decrementable_iterator(it), \
|
||||
safe_mode::not_decrementable_iterator);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,cont) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_is_owner(it,cont), \
|
||||
safe_mode::not_owner);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_SAME_OWNER(it0,it1) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_same_owner(it0,it1), \
|
||||
safe_mode::not_same_owner);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_VALID_RANGE(it0,it1) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_valid_range(it0,it1), \
|
||||
safe_mode::invalid_range);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(it,it0,it1) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_outside_range(it,it0,it1), \
|
||||
safe_mode::inside_range);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(it,n) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_in_bounds(it,n), \
|
||||
safe_mode::out_of_bounds);
|
||||
|
||||
#define BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(cont0,cont1) \
|
||||
BOOST_MULTI_INDEX_SAFE_MODE_ASSERT( \
|
||||
safe_mode::check_different_container(cont0,cont1), \
|
||||
safe_mode::same_container);
|
||||
|
||||
#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
|
||||
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
|
||||
#include <algorithm>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/multi_index/detail/access_specifier.hpp>
|
||||
#include <boost/multi_index/detail/iter_adaptor.hpp>
|
||||
#include <boost/multi_index/safe_mode_errors.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
|
||||
#include <boost/serialization/split_member.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_THREADS)
|
||||
#include <boost/detail/lightweight_mutex.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
namespace multi_index{
|
||||
|
||||
namespace safe_mode{
|
||||
|
||||
/* Checking routines. Assume the best for unchecked iterators
|
||||
* (i.e. they pass the checking when there is not enough info
|
||||
* to know.)
|
||||
*/
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_valid_iterator(const Iterator& it)
|
||||
{
|
||||
return it.valid()||it.unchecked();
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_dereferenceable_iterator(const Iterator& it)
|
||||
{
|
||||
return (it.valid()&&it!=it.owner()->end())||it.unchecked();
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_incrementable_iterator(const Iterator& it)
|
||||
{
|
||||
return (it.valid()&&it!=it.owner()->end())||it.unchecked();
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_decrementable_iterator(const Iterator& it)
|
||||
{
|
||||
return (it.valid()&&it!=it.owner()->begin())||it.unchecked();
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_is_owner(
|
||||
const Iterator& it,const typename Iterator::container_type& cont)
|
||||
{
|
||||
return (it.valid()&&it.owner()==&cont)||it.unchecked();
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_same_owner(const Iterator& it0,const Iterator& it1)
|
||||
{
|
||||
return (it0.valid()&&it1.valid()&&it0.owner()==it1.owner())||
|
||||
it0.unchecked()||it1.unchecked();
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_valid_range(const Iterator& it0,const Iterator& it1)
|
||||
{
|
||||
if(!check_same_owner(it0,it1))return false;
|
||||
|
||||
if(it0.valid()){
|
||||
Iterator last=it0.owner()->end();
|
||||
if(it1==last)return true;
|
||||
|
||||
for(Iterator first=it0;first!=last;++first){
|
||||
if(first==it1)return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename Iterator>
|
||||
inline bool check_outside_range(
|
||||
const Iterator& it,const Iterator& it0,const Iterator& it1)
|
||||
{
|
||||
if(!check_same_owner(it0,it1))return false;
|
||||
|
||||
if(it0.valid()){
|
||||
Iterator last=it0.owner()->end();
|
||||
bool found=false;
|
||||
|
||||
Iterator first=it0;
|
||||
for(;first!=last;++first){
|
||||
if(first==it1)break;
|
||||
|
||||
/* crucial that this check goes after previous break */
|
||||
|
||||
if(first==it)found=true;
|
||||
}
|
||||
if(first!=it1)return false;
|
||||
return !found;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename Iterator,typename Difference>
|
||||
inline bool check_in_bounds(const Iterator& it,Difference n)
|
||||
{
|
||||
if(it.unchecked())return true;
|
||||
if(!it.valid()) return false;
|
||||
if(n>0) return it.owner()->end()-it>=n;
|
||||
else return it.owner()->begin()-it<=n;
|
||||
}
|
||||
|
||||
template<typename Container>
|
||||
inline bool check_different_container(
|
||||
const Container& cont0,const Container& cont1)
|
||||
{
|
||||
return &cont0!=&cont1;
|
||||
}
|
||||
|
||||
/* Invalidates all iterators equivalent to that given. Safe containers
|
||||
* must call this when deleting elements: the safe mode framework cannot
|
||||
* perform this operation automatically without outside help.
|
||||
*/
|
||||
|
||||
template<typename Iterator>
|
||||
inline void detach_equivalent_iterators(Iterator& it)
|
||||
{
|
||||
if(it.valid()){
|
||||
{
|
||||
#if defined(BOOST_HAS_THREADS)
|
||||
boost::detail::lightweight_mutex::scoped_lock lock(it.cont->mutex);
|
||||
#endif
|
||||
|
||||
Iterator *prev_,*next_;
|
||||
for(
|
||||
prev_=static_cast<Iterator*>(&it.cont->header);
|
||||
(next_=static_cast<Iterator*>(prev_->next))!=0;){
|
||||
if(next_!=&it&&*next_==it){
|
||||
prev_->next=next_->next;
|
||||
next_->cont=0;
|
||||
}
|
||||
else prev_=next_;
|
||||
}
|
||||
}
|
||||
it.detach();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Container> class safe_container; /* fwd decl. */
|
||||
|
||||
} /* namespace multi_index::safe_mode */
|
||||
|
||||
namespace detail{
|
||||
|
||||
class safe_container_base; /* fwd decl. */
|
||||
|
||||
class safe_iterator_base
|
||||
{
|
||||
public:
|
||||
bool valid()const{return cont!=0;}
|
||||
bool unchecked()const{return unchecked_;}
|
||||
|
||||
inline void detach();
|
||||
|
||||
void uncheck()
|
||||
{
|
||||
detach();
|
||||
unchecked_=true;
|
||||
}
|
||||
|
||||
protected:
|
||||
safe_iterator_base():cont(0),next(0),unchecked_(false){}
|
||||
|
||||
explicit safe_iterator_base(safe_container_base* cont_):
|
||||
unchecked_(false)
|
||||
{
|
||||
attach(cont_);
|
||||
}
|
||||
|
||||
safe_iterator_base(const safe_iterator_base& it):
|
||||
unchecked_(it.unchecked_)
|
||||
{
|
||||
attach(it.cont);
|
||||
}
|
||||
|
||||
safe_iterator_base& operator=(const safe_iterator_base& it)
|
||||
{
|
||||
unchecked_=it.unchecked_;
|
||||
safe_container_base* new_cont=it.cont;
|
||||
if(cont!=new_cont){
|
||||
detach();
|
||||
attach(new_cont);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
~safe_iterator_base()
|
||||
{
|
||||
detach();
|
||||
}
|
||||
|
||||
const safe_container_base* owner()const{return cont;}
|
||||
|
||||
BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS:
|
||||
friend class safe_container_base;
|
||||
|
||||
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
|
||||
template<typename> friend class safe_mode::safe_container;
|
||||
template<typename Iterator> friend
|
||||
void safe_mode::detach_equivalent_iterators(Iterator&);
|
||||
#endif
|
||||
|
||||
inline void attach(safe_container_base* cont_);
|
||||
|
||||
safe_container_base* cont;
|
||||
safe_iterator_base* next;
|
||||
bool unchecked_;
|
||||
};
|
||||
|
||||
class safe_container_base:private noncopyable
|
||||
{
|
||||
public:
|
||||
safe_container_base(){}
|
||||
|
||||
BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
|
||||
friend class safe_iterator_base;
|
||||
|
||||
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
|
||||
template<typename Iterator> friend
|
||||
void safe_mode::detach_equivalent_iterators(Iterator&);
|
||||
#endif
|
||||
|
||||
~safe_container_base()
|
||||
{
|
||||
/* Detaches all remaining iterators, which by now will
|
||||
* be those pointing to the end of the container.
|
||||
*/
|
||||
|
||||
for(safe_iterator_base* it=header.next;it;it=it->next)it->cont=0;
|
||||
header.next=0;
|
||||
}
|
||||
|
||||
void swap(safe_container_base& x)
|
||||
{
|
||||
for(safe_iterator_base* it0=header.next;it0;it0=it0->next)it0->cont=&x;
|
||||
for(safe_iterator_base* it1=x.header.next;it1;it1=it1->next)it1->cont=this;
|
||||
std::swap(header.cont,x.header.cont);
|
||||
std::swap(header.next,x.header.next);
|
||||
}
|
||||
|
||||
safe_iterator_base header;
|
||||
|
||||
#if defined(BOOST_HAS_THREADS)
|
||||
boost::detail::lightweight_mutex mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
void safe_iterator_base::attach(safe_container_base* cont_)
|
||||
{
|
||||
cont=cont_;
|
||||
if(cont){
|
||||
#if defined(BOOST_HAS_THREADS)
|
||||
boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
|
||||
#endif
|
||||
|
||||
next=cont->header.next;
|
||||
cont->header.next=this;
|
||||
}
|
||||
}
|
||||
|
||||
void safe_iterator_base::detach()
|
||||
{
|
||||
if(cont){
|
||||
#if defined(BOOST_HAS_THREADS)
|
||||
boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
|
||||
#endif
|
||||
|
||||
safe_iterator_base *prev_,*next_;
|
||||
for(prev_=&cont->header;(next_=prev_->next)!=this;prev_=next_){}
|
||||
prev_->next=next;
|
||||
cont=0;
|
||||
}
|
||||
}
|
||||
|
||||
} /* namespace multi_index::detail */
|
||||
|
||||
namespace safe_mode{
|
||||
|
||||
/* In order to enable safe mode on a container:
|
||||
* - The container must derive from safe_container<container_type>,
|
||||
* - iterators must be generated via safe_iterator, which adapts a
|
||||
* preexistent unsafe iterator class.
|
||||
*/
|
||||
|
||||
template<typename Container>
|
||||
class safe_container;
|
||||
|
||||
template<typename Iterator,typename Container>
|
||||
class safe_iterator:
|
||||
public detail::iter_adaptor<safe_iterator<Iterator,Container>,Iterator>,
|
||||
public detail::safe_iterator_base
|
||||
{
|
||||
typedef detail::iter_adaptor<safe_iterator,Iterator> super;
|
||||
typedef detail::safe_iterator_base safe_super;
|
||||
|
||||
public:
|
||||
typedef Container container_type;
|
||||
typedef typename Iterator::reference reference;
|
||||
typedef typename Iterator::difference_type difference_type;
|
||||
|
||||
safe_iterator(){}
|
||||
explicit safe_iterator(safe_container<container_type>* cont_):
|
||||
safe_super(cont_){}
|
||||
template<typename T0>
|
||||
safe_iterator(const T0& t0,safe_container<container_type>* cont_):
|
||||
super(Iterator(t0)),safe_super(cont_){}
|
||||
template<typename T0,typename T1>
|
||||
safe_iterator(
|
||||
const T0& t0,const T1& t1,safe_container<container_type>* cont_):
|
||||
super(Iterator(t0,t1)),safe_super(cont_){}
|
||||
|
||||
safe_iterator& operator=(const safe_iterator& x)
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
|
||||
this->base_reference()=x.base_reference();
|
||||
safe_super::operator=(x);
|
||||
return *this;
|
||||
}
|
||||
|
||||
const container_type* owner()const
|
||||
{
|
||||
return
|
||||
static_cast<const container_type*>(
|
||||
static_cast<const safe_container<container_type>*>(
|
||||
this->safe_super::owner()));
|
||||
}
|
||||
|
||||
/* get_node is not to be used by the user */
|
||||
|
||||
typedef typename Iterator::node_type node_type;
|
||||
|
||||
node_type* get_node()const{return this->base_reference().get_node();}
|
||||
|
||||
private:
|
||||
friend class boost::multi_index::detail::iter_adaptor_access;
|
||||
|
||||
reference dereference()const
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
|
||||
BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(*this);
|
||||
return *(this->base_reference());
|
||||
}
|
||||
|
||||
bool equal(const safe_iterator& x)const
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
|
||||
BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
|
||||
return this->base_reference()==x.base_reference();
|
||||
}
|
||||
|
||||
void increment()
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
|
||||
BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(*this);
|
||||
++(this->base_reference());
|
||||
}
|
||||
|
||||
void decrement()
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
|
||||
BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(*this);
|
||||
--(this->base_reference());
|
||||
}
|
||||
|
||||
void advance(difference_type n)
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
|
||||
BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(*this,n);
|
||||
this->base_reference()+=n;
|
||||
}
|
||||
|
||||
difference_type distance_to(const safe_iterator& x)const
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
|
||||
BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
|
||||
return x.base_reference()-this->base_reference();
|
||||
}
|
||||
|
||||
#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
|
||||
/* Serialization. Note that Iterator::save and Iterator:load
|
||||
* are assumed to be defined and public: at first sight it seems
|
||||
* like we could have resorted to the public serialization interface
|
||||
* for doing the forwarding to the adapted iterator class:
|
||||
* ar<<base_reference();
|
||||
* ar>>base_reference();
|
||||
* but this would cause incompatibilities if a saving
|
||||
* program is in safe mode and the loading program is not, or
|
||||
* viceversa --in safe mode, the archived iterator data is one layer
|
||||
* deeper, this is especially relevant with XML archives.
|
||||
* It'd be nice if Boost.Serialization provided some forwarding
|
||||
* facility for use by adaptor classes.
|
||||
*/
|
||||
|
||||
friend class boost::serialization::access;
|
||||
|
||||
BOOST_SERIALIZATION_SPLIT_MEMBER()
|
||||
|
||||
template<class Archive>
|
||||
void save(Archive& ar,const unsigned int version)const
|
||||
{
|
||||
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
|
||||
this->base_reference().save(ar,version);
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void load(Archive& ar,const unsigned int version)
|
||||
{
|
||||
this->base_reference().load(ar,version);
|
||||
safe_super::uncheck();
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
template<typename Container>
|
||||
class safe_container:public detail::safe_container_base
|
||||
{
|
||||
typedef detail::safe_container_base super;
|
||||
|
||||
public:
|
||||
void detach_dereferenceable_iterators()
|
||||
{
|
||||
typedef typename Container::iterator iterator;
|
||||
|
||||
iterator end_=static_cast<Container*>(this)->end();
|
||||
iterator *prev_,*next_;
|
||||
for(
|
||||
prev_=static_cast<iterator*>(&this->header);
|
||||
(next_=static_cast<iterator*>(prev_->next))!=0;){
|
||||
if(*next_!=end_){
|
||||
prev_->next=next_->next;
|
||||
next_->cont=0;
|
||||
}
|
||||
else prev_=next_;
|
||||
}
|
||||
}
|
||||
|
||||
void swap(safe_container<Container>& x)
|
||||
{
|
||||
super::swap(x);
|
||||
}
|
||||
};
|
||||
|
||||
} /* namespace multi_index::safe_mode */
|
||||
|
||||
} /* namespace multi_index */
|
||||
|
||||
#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
|
||||
namespace serialization{
|
||||
template<typename Iterator,typename Container>
|
||||
struct version<
|
||||
boost::multi_index::safe_mode::safe_iterator<Iterator,Container>
|
||||
>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(
|
||||
int,value=boost::serialization::version<Iterator>::value);
|
||||
};
|
||||
} /* namespace serialization */
|
||||
#endif
|
||||
|
||||
} /* namespace boost */
|
||||
|
||||
#endif /* BOOST_MULTI_INDEX_ENABLE_SAFE_MODE */
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,83 @@
|
||||
/*==============================================================================
|
||||
Copyright (c) 2001-2010 Joel de Guzman
|
||||
Copyright (c) 2010 Thomas Heller
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
#ifndef BOOST_PHOENIX_OBJECT_CONSTRUCT_HPP
|
||||
#define BOOST_PHOENIX_OBJECT_CONSTRUCT_HPP
|
||||
|
||||
#include <boost/phoenix/core/limits.hpp>
|
||||
#include <boost/phoenix/core/call.hpp>
|
||||
#include <boost/phoenix/core/expression.hpp>
|
||||
#include <boost/phoenix/core/meta_grammar.hpp>
|
||||
#include <boost/phoenix/object/detail/target.hpp>
|
||||
#include <boost/phoenix/support/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
|
||||
#ifdef BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
|
||||
# include <boost/phoenix/object/detail/cpp03/construct_expr.hpp>
|
||||
#else
|
||||
BOOST_PHOENIX_DEFINE_EXPRESSION_VARARG(
|
||||
(boost)(phoenix)(construct)
|
||||
, (proto::terminal<detail::target<proto::_> >)
|
||||
(meta_grammar)
|
||||
, _
|
||||
)
|
||||
#endif
|
||||
|
||||
namespace boost { namespace phoenix
|
||||
{
|
||||
struct construct_eval
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
#if defined(BOOST_PHOENIX_NO_VARIADIC_OBJECT)
|
||||
template <typename This, typename A0, typename Context>
|
||||
struct result<This(A0, Context)>
|
||||
: detail::result_of::target<A0>
|
||||
{
|
||||
};
|
||||
|
||||
template <typename Target, typename Context>
|
||||
typename detail::result_of::target<Target>::type
|
||||
operator()(Target, Context const &) const
|
||||
{
|
||||
return typename detail::result_of::target<Target>::type();
|
||||
}
|
||||
|
||||
// Bring in the rest
|
||||
#include <boost/phoenix/object/detail/cpp03/construct_eval.hpp>
|
||||
#else
|
||||
// TODO:
|
||||
#endif
|
||||
};
|
||||
|
||||
template <typename Dummy>
|
||||
struct default_actions::when<rule::construct, Dummy>
|
||||
: call<construct_eval, Dummy>
|
||||
{};
|
||||
|
||||
#if defined(BOOST_PHOENIX_NO_VARIADIC_OBJECT)
|
||||
template <typename T>
|
||||
inline
|
||||
typename expression::construct<detail::target<T> >::type const
|
||||
construct()
|
||||
{
|
||||
return
|
||||
expression::
|
||||
construct<detail::target<T> >::
|
||||
make(detail::target<T>());
|
||||
}
|
||||
|
||||
// Bring in the rest
|
||||
#include <boost/phoenix/object/detail/cpp03/construct.hpp>
|
||||
#else
|
||||
// TODO:
|
||||
#endif
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,399 @@
|
||||
#ifndef NETWORK_MESSAGE_HPP__
|
||||
#define NETWORK_MESSAGE_HPP__
|
||||
|
||||
/*
|
||||
* WSJT-X Message Formats
|
||||
* ======================
|
||||
*
|
||||
* All messages are written or read using the QDataStream derivatives
|
||||
* defined below, note that we are using the default for floating
|
||||
* point precision which means all are double precision i.e. 64-bit
|
||||
* IEEE format.
|
||||
*
|
||||
* Message is big endian format
|
||||
*
|
||||
* Header format:
|
||||
*
|
||||
* 32-bit unsigned integer magic number 0xadbccbda
|
||||
* 32-bit unsigned integer schema number
|
||||
*
|
||||
* Payload format:
|
||||
*
|
||||
* As per the QDataStream format, see below for version used and
|
||||
* here:
|
||||
*
|
||||
* http://doc.qt.io/qt-5/datastreamformat.html
|
||||
*
|
||||
* for the serialization details for each type, at the time of
|
||||
* writing the above document is for Qt_5_0 format which is buggy
|
||||
* so we use Qt_5_4 format, differences are:
|
||||
*
|
||||
* QDateTime:
|
||||
* QDate qint64 Julian day number
|
||||
* QTime quint32 Milli-seconds since midnight
|
||||
* timespec quint8 0=local, 1=UTC, 2=Offset from UTC
|
||||
* (seconds)
|
||||
* 3=time zone
|
||||
* offset qint32 only present if timespec=2
|
||||
* timezone several-fields only present if timespec=3
|
||||
*
|
||||
* we will avoid using QDateTime fields with time zones for simplicity.
|
||||
*
|
||||
* Type utf8 is a utf-8 byte string formatted as a QByteArray for
|
||||
* serialization purposes (currently a quint32 size followed by size
|
||||
* bytes, no terminator is present or counted).
|
||||
*
|
||||
* The QDataStream format document linked above is not complete for
|
||||
* the QByteArray serialization format, it is similar to the QString
|
||||
* serialization format in that it differentiates between empty
|
||||
* strings and null strings. Empty strings have a length of zero
|
||||
* whereas null strings have a length field of 0xffffffff.
|
||||
*
|
||||
* Schema Negotiation
|
||||
* ------------------
|
||||
*
|
||||
* The NetworkMessage::Builder class specifies a schema number which
|
||||
* may be incremented from time to time. It represents a version of
|
||||
* the underlying encoding schemes used to store data items. Since the
|
||||
* underlying encoding is defined by the Qt project in it's
|
||||
* QDataStream stream operators, it is essential that clients and
|
||||
* servers of this protocol can agree on a common scheme. The
|
||||
* NetworkMessage utility classes below exchange the schema number
|
||||
* actually used. The handling of the schema is backwards compatible
|
||||
* to an extent, so long as clients and servers are written
|
||||
* correctly. For example a server written to any particular schema
|
||||
* version can communicate with a client written to a later schema.
|
||||
*
|
||||
* Schema Version 1:- this schema used the QDataStream::Qt_5_0 version
|
||||
* which is broken.
|
||||
*
|
||||
* Schema Version 2:- this schema uses the QDataStream::Qt_5_2 version.
|
||||
*
|
||||
* Schema Version 3:- this schema uses the QDataStream::Qt_5_4 version.
|
||||
*
|
||||
*
|
||||
*
|
||||
* Message Direction Value Type
|
||||
* ------------- --------- ---------------------- -----------
|
||||
* Heartbeat Out/In 0 quint32
|
||||
* Id (unique key) utf8
|
||||
* Maximum schema number quint32
|
||||
* version utf8
|
||||
* revision utf8
|
||||
*
|
||||
* The heartbeat message shall be sent on a periodic basis every
|
||||
* NetworkMessage::pulse seconds (see below), the WSJT-X
|
||||
* application does that using the MessageClient class. This
|
||||
* message is intended to be used by servers to detect the presence
|
||||
* of a client and also the unexpected disappearance of a client
|
||||
* and by clients to learn the schema negotiated by the server
|
||||
* after it receives the initial heartbeat message from a client.
|
||||
* The message_aggregator reference server does just that using the
|
||||
* MessageServer class. Upon initial startup a client must send a
|
||||
* heartbeat message as soon as is practical, this message is used
|
||||
* to negotiate the maximum schema number common to the client and
|
||||
* server. Note that the server may not be able to support the
|
||||
* client's requested maximum schema number, in which case the
|
||||
* first message received from the server will specify a lower
|
||||
* schema number (never a higher one as that is not allowed). If a
|
||||
* server replies with a lower schema number then no higher than
|
||||
* that number shall be used for all further outgoing messages from
|
||||
* either clients or the server itself.
|
||||
*
|
||||
* Note: the "Maximum schema number" field was introduced at the
|
||||
* same time as schema 3, therefore servers and clients must assume
|
||||
* schema 2 is the highest schema number supported if the Heartbeat
|
||||
* message does not contain the "Maximum schema number" field.
|
||||
*
|
||||
*
|
||||
* Status Out 1 quint32
|
||||
* Id (unique key) utf8
|
||||
* Dial Frequency (Hz) quint64
|
||||
* Mode utf8
|
||||
* DX call utf8
|
||||
* Report utf8
|
||||
* Tx Mode utf8
|
||||
* Tx Enabled bool
|
||||
* Transmitting bool
|
||||
* Decoding bool
|
||||
* Rx DF qint32
|
||||
* Tx DF qint32
|
||||
* DE call utf8
|
||||
* DE grid utf8
|
||||
* DX grid utf8
|
||||
* Tx Watchdog bool
|
||||
* Sub-mode utf8
|
||||
* Fast mode bool
|
||||
*
|
||||
* WSJT-X sends this status message when various internal state
|
||||
* changes to allow the server to track the relevant state of each
|
||||
* client without the need for polling commands. The current state
|
||||
* changes that generate status messages are:
|
||||
*
|
||||
* Application start up,
|
||||
* "Enable Tx" button status changes,
|
||||
* Dial frequency changes,
|
||||
* Changes to the "DX Call" field,
|
||||
* Operating mode, sub-mode or fast mode changes,
|
||||
* Transmit mode changed (in dual JT9+JT65 mode),
|
||||
* Changes to the "Rpt" spinner,
|
||||
* After an old decodes replay sequence (see Replay below),
|
||||
* When switching between Tx and Rx mode,
|
||||
* At the start and end of decoding,
|
||||
* When the Rx DF changes,
|
||||
* When the Tx DF changes,
|
||||
* When the DE call or grid changes (currently when settings are exited),
|
||||
* When the DX call or grid changes,
|
||||
* When the Tx watchdog is set or reset.
|
||||
*
|
||||
*
|
||||
* Decode Out 2 quint32
|
||||
* Id (unique key) utf8
|
||||
* New bool
|
||||
* Time QTime
|
||||
* snr qint32
|
||||
* Delta time (S) float (serialized as double)
|
||||
* Delta frequency (Hz) quint32
|
||||
* Mode utf8
|
||||
* Message utf8
|
||||
* Low confidence bool
|
||||
*
|
||||
* The decode message is sent when a new decode is completed, in
|
||||
* this case the 'New' field is true. It is also used in response
|
||||
* to a "Replay" message where each old decode in the "Band
|
||||
* activity" window, that has not been erased, is sent in order
|
||||
* as a one of these messages with the 'New' field set to false.
|
||||
* See the "Replay" message below for details of usage. Low
|
||||
* confidence decodes are flagged in protocols where the decoder
|
||||
* has knows that a decode has a higher than normal probability
|
||||
* of being false, they should not be reported on publicly
|
||||
* accessible services without some attached warning or further
|
||||
* validation.
|
||||
*
|
||||
*
|
||||
* Clear Out 3 quint32
|
||||
* Id (unique key) utf8
|
||||
*
|
||||
* This message is send when all prior "Decode" messages in the
|
||||
* "Band activity" window have been discarded and therefore are
|
||||
* no long available for actioning with a "Reply" message. It is
|
||||
* sent when the user erases the "Band activity" window and when
|
||||
* WSJT-X closes down normally. The server should discard all
|
||||
* decode messages upon receipt of this message.
|
||||
*
|
||||
*
|
||||
* Reply In 4 quint32
|
||||
* Id (target unique key) utf8
|
||||
* Time QTime
|
||||
* snr qint32
|
||||
* Delta time (S) float (serialized as double)
|
||||
* Delta frequency (Hz) quint32
|
||||
* Mode utf8
|
||||
* Message utf8
|
||||
* Low confidence bool
|
||||
*
|
||||
* In order for a server to provide a useful cooperative service
|
||||
* to WSJT-X it is possible for it to initiate a QSO by sending
|
||||
* this message to a client. WSJT-X filters this message and only
|
||||
* acts upon it if the message exactly describes a prior decode
|
||||
* and that decode is a CQ or QRZ message. The action taken is
|
||||
* exactly equivalent to the user double clicking the message in
|
||||
* the "Band activity" window. The intent of this message is for
|
||||
* servers to be able to provide an advanced look up of potential
|
||||
* QSO partners, for example determining if they have been worked
|
||||
* before or if working them may advance some objective like
|
||||
* award progress. The intention is not to provide a secondary
|
||||
* user interface for WSJT-X, it is expected that after QSO
|
||||
* initiation the rest of the QSO is carried out manually using
|
||||
* the normal WSJT-X user interface.
|
||||
*
|
||||
*
|
||||
* QSO Logged Out 5 quint32
|
||||
* Id (unique key) utf8
|
||||
* Date & Time Off QDateTime
|
||||
* DX call utf8
|
||||
* DX grid utf8
|
||||
* Dial frequency (Hz) quint64
|
||||
* Mode utf8
|
||||
* Report send utf8
|
||||
* Report received utf8
|
||||
* Tx power utf8
|
||||
* Comments utf8
|
||||
* Name utf8
|
||||
* Date & Time On QDateTime
|
||||
*
|
||||
* The QSO logged message is sent to the server(s) when the
|
||||
* WSJT-X user accepts the "Log QSO" dialog by clicking the "OK"
|
||||
* button.
|
||||
*
|
||||
*
|
||||
* Close Out 6 quint32
|
||||
* Id (unique key) utf8
|
||||
*
|
||||
* Close is sent by a client immediately prior to it shutting
|
||||
* down gracefully.
|
||||
*
|
||||
*
|
||||
* Replay In 7 quint32
|
||||
* Id (unique key) utf8
|
||||
*
|
||||
* When a server starts it may be useful for it to determine the
|
||||
* state of preexisting clients. Sending this message to each
|
||||
* client as it is discovered will cause that client (WSJT-X) to
|
||||
* send a "Decode" message for each decode currently in its "Band
|
||||
* activity" window. Each "Decode" message sent will have the
|
||||
* "New" flag set to false so that they can be distinguished from
|
||||
* new decodes. After all the old decodes have been broadcast a
|
||||
* "Status" message is also broadcast. If the server wishes to
|
||||
* determine the status of a newly discovered client; this
|
||||
* message should be used.
|
||||
*
|
||||
*
|
||||
* Halt Tx In 8
|
||||
* Id (unique key) utf8
|
||||
* Auto Tx Only bool
|
||||
*
|
||||
* The server may stop a client from transmitting messages either
|
||||
* immediately or at the end of the current transmission period
|
||||
* using this message.
|
||||
*
|
||||
*
|
||||
* Free Text In 9
|
||||
* Id (unique key) utf8
|
||||
* Text utf8
|
||||
* Send bool
|
||||
*
|
||||
* This message allows the server to set the current free text
|
||||
* message content. Sending this message with a non-empty "Text"
|
||||
* field is equivalent to typing a new message (old contents are
|
||||
* discarded) in to the WSJT-X free text message field or "Tx5"
|
||||
* field (both are updated) and if the "Send" flag is set then
|
||||
* clicking the "Now" radio button for the "Tx5" field if tab one
|
||||
* is current or clicking the "Free msg" radio button if tab two
|
||||
* is current.
|
||||
*
|
||||
* It is the responsibility of the sender to limit the length of
|
||||
* the message text and to limit it to legal message
|
||||
* characters. Despite this, it may be difficult for the sender
|
||||
* to determine the maximum message length without reimplementing
|
||||
* the complete message encoding protocol. Because of this is may
|
||||
* be better to allow any reasonable message length and to let
|
||||
* the WSJT-X application encode and possibly truncate the actual
|
||||
* on-air message.
|
||||
*
|
||||
* If the message text is empty the meaning of the message is
|
||||
* refined to send the current free text unchanged when the
|
||||
* "Send" flag is set or to clear the current free text when the
|
||||
* "Send" flag is unset. Note that this API does not include a
|
||||
* command to determine the contents of the current free text
|
||||
* message.
|
||||
*
|
||||
* WSPRDecode Out 10 quint32
|
||||
* Id (unique key) utf8
|
||||
* New bool
|
||||
* Time QTime
|
||||
* snr qint32
|
||||
* Delta time (S) float (serialized as double)
|
||||
* Frequency (Hz) quint64
|
||||
* Drift (Hz) qint32
|
||||
* Callsign utf8
|
||||
* Grid utf8
|
||||
* Power (dBm) qint32
|
||||
*
|
||||
* The decode message is sent when a new decode is completed, in
|
||||
* this case the 'New' field is true. It is also used in response
|
||||
* to a "Replay" message where each old decode in the "Band
|
||||
* activity" window, that has not been erased, is sent in order
|
||||
* as a one of these messages with the 'New' field set to
|
||||
* false. See the "Replay" message below for details of usage.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include <QDataStream>
|
||||
|
||||
#include "pimpl_h.hpp"
|
||||
|
||||
class QIODevice;
|
||||
class QByteArray;
|
||||
class QString;
|
||||
|
||||
namespace NetworkMessage
|
||||
{
|
||||
// NEVER DELETE MESSAGE TYPES
|
||||
enum Type
|
||||
{
|
||||
Heartbeat,
|
||||
Status,
|
||||
Decode,
|
||||
Clear,
|
||||
Reply,
|
||||
QSOLogged,
|
||||
Close,
|
||||
Replay,
|
||||
HaltTx,
|
||||
FreeText,
|
||||
WSPRDecode,
|
||||
maximum_message_type_ // ONLY add new message types
|
||||
// immediately before here
|
||||
};
|
||||
|
||||
quint32 constexpr pulse {15}; // seconds
|
||||
|
||||
//
|
||||
// NetworkMessage::Builder - build a message containing serialized Qt types
|
||||
//
|
||||
class Builder
|
||||
: public QDataStream
|
||||
{
|
||||
public:
|
||||
static quint32 constexpr magic {0xadbccbda}; // never change this
|
||||
|
||||
// increment this if a newer Qt schema is required and add decode
|
||||
// logic to the Builder and Reader class implementations
|
||||
#if QT_VERSION >= 0x050400
|
||||
static quint32 constexpr schema_number {3};
|
||||
#elif QT_VERSION >= 0x050200
|
||||
static quint32 constexpr schema_number {2};
|
||||
#else
|
||||
// Schema 1 (Qt_5_0) is broken
|
||||
#error "Qt version 5.2 or greater required"
|
||||
#endif
|
||||
|
||||
explicit Builder (QIODevice *, Type, QString const& id, quint32 schema);
|
||||
explicit Builder (QByteArray *, Type, QString const& id, quint32 schema);
|
||||
Builder (Builder const&) = delete;
|
||||
Builder& operator = (Builder const&) = delete;
|
||||
|
||||
private:
|
||||
void common_initialization (Type type, QString const& id, quint32 schema);
|
||||
};
|
||||
|
||||
//
|
||||
// NetworkMessage::Reader - read a message containing serialized Qt types
|
||||
//
|
||||
// Message is as per NetworkMessage::Builder above, the schema()
|
||||
// member may be used to determine the schema of the original
|
||||
// message.
|
||||
//
|
||||
class Reader
|
||||
: public QDataStream
|
||||
{
|
||||
public:
|
||||
explicit Reader (QIODevice *);
|
||||
explicit Reader (QByteArray const&);
|
||||
Reader (Reader const&) = delete;
|
||||
Reader& operator = (Reader const&) = delete;
|
||||
~Reader ();
|
||||
|
||||
quint32 schema () const;
|
||||
Type type () const;
|
||||
QString id () const;
|
||||
|
||||
private:
|
||||
class impl;
|
||||
pimpl<impl> m_;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,21 @@
|
||||
|
||||
#ifndef BOOST_MPL_MINUS_HPP_INCLUDED
|
||||
#define BOOST_MPL_MINUS_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$
|
||||
|
||||
#define AUX778076_OP_NAME minus
|
||||
#define AUX778076_OP_TOKEN -
|
||||
#include <boost/mpl/aux_/arithmetic_op.hpp>
|
||||
|
||||
#endif // BOOST_MPL_MINUS_HPP_INCLUDED
|
||||
@@ -0,0 +1,600 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright Christopher Kormanyos 2014.
|
||||
// Copyright John Maddock 2014.
|
||||
// Copyright Paul Bristow 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)
|
||||
//
|
||||
|
||||
// Implement quadruple-precision <cmath> support.
|
||||
|
||||
#ifndef _BOOST_CSTDFLOAT_CMATH_2014_02_15_HPP_
|
||||
#define _BOOST_CSTDFLOAT_CMATH_2014_02_15_HPP_
|
||||
|
||||
#include <boost/math/cstdfloat/cstdfloat_types.hpp>
|
||||
#include <boost/math/cstdfloat/cstdfloat_limits.hpp>
|
||||
|
||||
#if defined(BOOST_CSTDFLOAT_HAS_INTERNAL_FLOAT128_T) && defined(BOOST_MATH_USE_FLOAT128) && !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_SUPPORT)
|
||||
|
||||
#include <cmath>
|
||||
#include <stdexcept>
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#if defined(_WIN32) && defined(__GNUC__)
|
||||
// Several versions of Mingw and probably cygwin too have broken
|
||||
// libquadmath implementations that segfault as soon as you call
|
||||
// expq or any function that depends on it.
|
||||
#define BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
|
||||
#endif
|
||||
|
||||
// Here is a helper function used for raising the value of a given
|
||||
// floating-point type to the power of n, where n has integral type.
|
||||
namespace boost { namespace math { namespace cstdfloat { namespace detail {
|
||||
|
||||
template<class float_type, class integer_type>
|
||||
inline float_type pown(const float_type& x, const integer_type p)
|
||||
{
|
||||
const bool isneg = (x < 0);
|
||||
const bool isnan = (x != x);
|
||||
const bool isinf = ((!isneg) ? bool(+x > (std::numeric_limits<float_type>::max)())
|
||||
: bool(-x > (std::numeric_limits<float_type>::max)()));
|
||||
|
||||
if(isnan) { return x; }
|
||||
|
||||
if(isinf) { return std::numeric_limits<float_type>::quiet_NaN(); }
|
||||
|
||||
const bool x_is_neg = (x < 0);
|
||||
const float_type abs_x = (x_is_neg ? -x : x);
|
||||
|
||||
if(p < static_cast<integer_type>(0))
|
||||
{
|
||||
if(abs_x < (std::numeric_limits<float_type>::min)())
|
||||
{
|
||||
return (x_is_neg ? -std::numeric_limits<float_type>::infinity()
|
||||
: +std::numeric_limits<float_type>::infinity());
|
||||
}
|
||||
else
|
||||
{
|
||||
return float_type(1) / pown(x, static_cast<integer_type>(-p));
|
||||
}
|
||||
}
|
||||
|
||||
if(p == static_cast<integer_type>(0))
|
||||
{
|
||||
return float_type(1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(p == static_cast<integer_type>(1)) { return x; }
|
||||
|
||||
if(abs_x > (std::numeric_limits<float_type>::max)())
|
||||
{
|
||||
return (x_is_neg ? -std::numeric_limits<float_type>::infinity()
|
||||
: +std::numeric_limits<float_type>::infinity());
|
||||
}
|
||||
|
||||
if (p == static_cast<integer_type>(2)) { return (x * x); }
|
||||
else if(p == static_cast<integer_type>(3)) { return ((x * x) * x); }
|
||||
else if(p == static_cast<integer_type>(4)) { const float_type x2 = (x * x); return (x2 * x2); }
|
||||
else
|
||||
{
|
||||
// The variable xn stores the binary powers of x.
|
||||
float_type result(((p % integer_type(2)) != integer_type(0)) ? x : float_type(1));
|
||||
float_type xn (x);
|
||||
|
||||
integer_type p2 = p;
|
||||
|
||||
while(integer_type(p2 /= 2) != integer_type(0))
|
||||
{
|
||||
// Square xn for each binary power.
|
||||
xn *= xn;
|
||||
|
||||
const bool has_binary_power = (integer_type(p2 % integer_type(2)) != integer_type(0));
|
||||
|
||||
if(has_binary_power)
|
||||
{
|
||||
// Multiply the result with each binary power contained in the exponent.
|
||||
result *= xn;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} } } } // boost::math::cstdfloat::detail
|
||||
|
||||
// We will now define preprocessor symbols representing quadruple-precision <cmath> functions.
|
||||
#if defined(BOOST_INTEL)
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LDEXP __ldexpq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FREXP __frexpq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FABS __fabsq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FLOOR __floorq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_CEIL __ceilq
|
||||
#if !defined(BOOST_CSTDFLOAT_FLOAT128_SQRT)
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_SQRT __sqrtq
|
||||
#endif
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TRUNC __truncq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_EXP __expq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_EXPM1 __expm1q
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_POW __powq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LOG __logq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LOG10 __log10q
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_SIN __sinq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_COS __cosq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TAN __tanq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ASIN __asinq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ACOS __acosq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ATAN __atanq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_SINH __sinhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_COSH __coshq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TANH __tanhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ASINH __asinhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ACOSH __acoshq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ATANH __atanhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FMOD __fmodq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ATAN2 __atan2q
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LGAMMA __lgammaq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TGAMMA __tgammaq
|
||||
#elif defined(__GNUC__)
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LDEXP ldexpq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FREXP frexpq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FABS fabsq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FLOOR floorq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_CEIL ceilq
|
||||
#if !defined(BOOST_CSTDFLOAT_FLOAT128_SQRT)
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_SQRT sqrtq
|
||||
#endif
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TRUNC truncq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_POW powq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LOG logq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LOG10 log10q
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_SIN sinq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_COS cosq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TAN tanq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ASIN asinq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ACOS acosq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ATAN atanq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_FMOD fmodq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ATAN2 atan2q
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_LGAMMA lgammaq
|
||||
#if !defined(BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS)
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_EXP expq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_EXPM1 expm1q_internal
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_SINH sinhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_COSH coshq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TANH tanhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ASINH asinhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ACOSH acoshq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ATANH atanhq
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TGAMMA tgammaq
|
||||
#else // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_EXP expq_patch
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_SINH sinhq_patch
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_COSH coshq_patch
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TANH tanhq_patch
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ASINH asinhq_patch
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ACOSH acoshq_patch
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_ATANH atanhq_patch
|
||||
#define BOOST_CSTDFLOAT_FLOAT128_TGAMMA tgammaq_patch
|
||||
#endif // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
|
||||
#endif
|
||||
|
||||
// Implement quadruple-precision <cmath> functions in the namespace
|
||||
// boost::math::cstdfloat::detail. Subsequently inject these into the
|
||||
// std namespace via *using* directive.
|
||||
|
||||
// Begin with some forward function declarations. Also implement patches
|
||||
// for compilers that have broken float128 exponential functions.
|
||||
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LDEXP (boost::math::cstdfloat::detail::float_internal128_t, int) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FREXP (boost::math::cstdfloat::detail::float_internal128_t, int*) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FABS (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FLOOR (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_CEIL (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SQRT (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TRUNC (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_POW (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LOG (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LOG10 (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SIN (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_COS (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TAN (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ASIN (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ACOS (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATAN (boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FMOD (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATAN2 (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LGAMMA(boost::math::cstdfloat::detail::float_internal128_t) throw();
|
||||
|
||||
#if !defined(BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS)
|
||||
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXP (boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SINH (boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_COSH (boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TANH (boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ASINH (boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ACOSH (boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATANH (boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TGAMMA(boost::math::cstdfloat::detail::float_internal128_t x) throw();
|
||||
|
||||
#else // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
|
||||
|
||||
// Forward declaration of the patched exponent function, exp(x).
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXP (boost::math::cstdfloat::detail::float_internal128_t x);
|
||||
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXPM1 (boost::math::cstdfloat::detail::float_internal128_t x)
|
||||
{
|
||||
// Compute exp(x) - 1 for x small.
|
||||
|
||||
// Use an order-36 polynomial approximation of the exponential function
|
||||
// in the range of (-ln2 < x < ln2). Scale the argument to this range
|
||||
// and subsequently multiply the result by 2^n accordingly.
|
||||
|
||||
// Derive the polynomial coefficients with Mathematica(R) by generating
|
||||
// a table of high-precision values of exp(x) in the range (-ln2 < x < ln2)
|
||||
// and subsequently applying the built-in *Fit* function.
|
||||
|
||||
// Table[{x, Exp[x] - 1}, {x, -Log[2], Log[2], 1/180}]
|
||||
// N[%, 120]
|
||||
// Fit[%, {x, x^2, x^3, x^4, x^5, x^6, x^7, x^8, x^9, x^10, x^11, x^12,
|
||||
// x^13, x^14, x^15, x^16, x^17, x^18, x^19, x^20, x^21, x^22,
|
||||
// x^23, x^24, x^25, x^26, x^27, x^28, x^29, x^30, x^31, x^32,
|
||||
// x^33, x^34, x^35, x^36}, x]
|
||||
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
|
||||
float_type sum;
|
||||
|
||||
if(x > BOOST_FLOAT128_C(0.693147180559945309417232121458176568075500134360255))
|
||||
{
|
||||
sum = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x) - float_type(1);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Compute the polynomial approximation of exp(alpha).
|
||||
sum = (((((((((((((((((((((((((((((((((((( float_type(BOOST_FLOAT128_C(2.69291698127774166063293705964720493864630783729857438187365E-42)) * x
|
||||
+ float_type(BOOST_FLOAT128_C(9.70937085471487654794114679403710456028986572118859594614033E-41))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(3.38715585158055097155585505318085512156885389014410753080500E-39))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.15162718532861050809222658798662695267019717760563645440433E-37))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(3.80039074689434663295873584133017767349635602413675471702393E-36))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.21612504934087520075905434734158045947460467096773246215239E-34))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(3.76998762883139753126119821241037824830069851253295480396224E-33))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.13099628863830344684998293828608215735777107850991029729440E-31))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(3.27988923706982293204067897468714277771890104022419696770352E-30))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(9.18368986379558482800593745627556950089950023355628325088207E-29))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(2.47959626322479746949155352659617642905315302382639380521497E-27))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(6.44695028438447337900255966737803112935639344283098705091949E-26))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.61173757109611834904452725462599961406036904573072897122957E-24))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(3.86817017063068403772269360016918092488847584660382953555804E-23))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(8.89679139245057328674891109315654704307721758924206107351744E-22))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.95729410633912612308475595397946731738088422488032228717097E-20))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(4.11031762331216485847799061511674191805055663711439605760231E-19))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(8.22063524662432971695598123977873600603370758794431071426640E-18))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.56192069685862264622163643500633782667263448653185159383285E-16))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(2.81145725434552076319894558300988749849555291507956994126835E-15))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(4.77947733238738529743820749111754320727153728139716409114011E-14))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(7.64716373181981647590113198578807092707697416852226691068627E-13))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.14707455977297247138516979786821056670509688396295740818677E-11))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(1.60590438368216145993923771701549479323291461578567184216302E-10))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(2.08767569878680989792100903212014323125428376052986408239620E-09))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(2.50521083854417187750521083854417187750523408006206780016659E-08))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(2.75573192239858906525573192239858906525573195144226062684604E-07))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(2.75573192239858906525573192239858906525573191310049321957902E-06))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.00002480158730158730158730158730158730158730158730149317774))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.00019841269841269841269841269841269841269841269841293575920))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.00138888888888888888888888888888888888888888888888889071045))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.00833333333333333333333333333333333333333333333333332986595))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.04166666666666666666666666666666666666666666666666666664876))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.16666666666666666666666666666666666666666666666666666669048))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.50000000000000000000000000000000000000000000000000000000006))) * x
|
||||
+ float_type(BOOST_FLOAT128_C(0.99999999999999999999999999999999999999999999999999999999995))) * x);
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXP (boost::math::cstdfloat::detail::float_internal128_t x)
|
||||
{
|
||||
// Patch the expq() function for a subset of broken GCC compilers
|
||||
// like GCC 4.7, 4.8 on MinGW.
|
||||
|
||||
// Use an order-36 polynomial approximation of the exponential function
|
||||
// in the range of (-ln2 < x < ln2). Scale the argument to this range
|
||||
// and subsequently multiply the result by 2^n accordingly.
|
||||
|
||||
// Derive the polynomial coefficients with Mathematica(R) by generating
|
||||
// a table of high-precision values of exp(x) in the range (-ln2 < x < ln2)
|
||||
// and subsequently applying the built-in *Fit* function.
|
||||
|
||||
// Table[{x, Exp[x] - 1}, {x, -Log[2], Log[2], 1/180}]
|
||||
// N[%, 120]
|
||||
// Fit[%, {x, x^2, x^3, x^4, x^5, x^6, x^7, x^8, x^9, x^10, x^11, x^12,
|
||||
// x^13, x^14, x^15, x^16, x^17, x^18, x^19, x^20, x^21, x^22,
|
||||
// x^23, x^24, x^25, x^26, x^27, x^28, x^29, x^30, x^31, x^32,
|
||||
// x^33, x^34, x^35, x^36}, x]
|
||||
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
|
||||
// Scale the argument x to the range (-ln2 < x < ln2).
|
||||
BOOST_CONSTEXPR_OR_CONST float_type one_over_ln2 = float_type(BOOST_FLOAT128_C(1.44269504088896340735992468100189213742664595415299));
|
||||
const float_type x_over_ln2 = x * one_over_ln2;
|
||||
|
||||
boost::int_fast32_t n;
|
||||
|
||||
if(x != x)
|
||||
{
|
||||
// The argument is NaN.
|
||||
return std::numeric_limits<float_type>::quiet_NaN();
|
||||
}
|
||||
else if(::BOOST_CSTDFLOAT_FLOAT128_FABS(x) > BOOST_FLOAT128_C(+0.693147180559945309417232121458176568075500134360255))
|
||||
{
|
||||
// The absolute value of the argument exceeds ln2.
|
||||
n = static_cast<boost::int_fast32_t>(::BOOST_CSTDFLOAT_FLOAT128_FLOOR(x_over_ln2));
|
||||
}
|
||||
else if(::BOOST_CSTDFLOAT_FLOAT128_FABS(x) < BOOST_FLOAT128_C(+0.693147180559945309417232121458176568075500134360255))
|
||||
{
|
||||
// The absolute value of the argument is less than ln2.
|
||||
n = static_cast<boost::int_fast32_t>(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
// The absolute value of the argument is exactly equal to ln2 (in the sense of floating-point equality).
|
||||
return float_type(2);
|
||||
}
|
||||
|
||||
// Check if the argument is very near an integer.
|
||||
const float_type floor_of_x = ::BOOST_CSTDFLOAT_FLOAT128_FLOOR(x);
|
||||
|
||||
if(::BOOST_CSTDFLOAT_FLOAT128_FABS(x - floor_of_x) < float_type(BOOST_CSTDFLOAT_FLOAT128_EPS))
|
||||
{
|
||||
// Return e^n for arguments very near an integer.
|
||||
return boost::math::cstdfloat::detail::pown(BOOST_FLOAT128_C(2.71828182845904523536028747135266249775724709369996), static_cast<boost::int_fast32_t>(floor_of_x));
|
||||
}
|
||||
|
||||
// Compute the scaled argument alpha.
|
||||
const float_type alpha = x - (n * BOOST_FLOAT128_C(0.693147180559945309417232121458176568075500134360255));
|
||||
|
||||
// Compute the polynomial approximation of expm1(alpha) and add to it
|
||||
// in order to obtain the scaled result.
|
||||
const float_type scaled_result = ::BOOST_CSTDFLOAT_FLOAT128_EXPM1(alpha) + float_type(1);
|
||||
|
||||
// Rescale the result and return it.
|
||||
return scaled_result * boost::math::cstdfloat::detail::pown(float_type(2), n);
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SINH (boost::math::cstdfloat::detail::float_internal128_t x)
|
||||
{
|
||||
// Patch the sinhq() function for a subset of broken GCC compilers
|
||||
// like GCC 4.7, 4.8 on MinGW.
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
|
||||
// Here, we use the following:
|
||||
// Set: ex = exp(x)
|
||||
// Set: em1 = expm1(x)
|
||||
// Then
|
||||
// sinh(x) = (ex - 1/ex) / 2 ; for |x| >= 1
|
||||
// sinh(x) = (2em1 + em1^2) / (2ex) ; for |x| < 1
|
||||
|
||||
const float_type ex = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x);
|
||||
|
||||
if(::BOOST_CSTDFLOAT_FLOAT128_FABS(x) < float_type(+1))
|
||||
{
|
||||
const float_type em1 = ::BOOST_CSTDFLOAT_FLOAT128_EXPM1(x);
|
||||
|
||||
return ((em1 * 2) + (em1 * em1)) / (ex * 2);
|
||||
}
|
||||
else
|
||||
{
|
||||
return (ex - (float_type(1) / ex)) / 2;
|
||||
}
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_COSH (boost::math::cstdfloat::detail::float_internal128_t x)
|
||||
{
|
||||
// Patch the coshq() function for a subset of broken GCC compilers
|
||||
// like GCC 4.7, 4.8 on MinGW.
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
const float_type ex = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x);
|
||||
return (ex + (float_type(1) / ex)) / 2;
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TANH (boost::math::cstdfloat::detail::float_internal128_t x)
|
||||
{
|
||||
// Patch the tanhq() function for a subset of broken GCC compilers
|
||||
// like GCC 4.7, 4.8 on MinGW.
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
const float_type ex_plus = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x);
|
||||
const float_type ex_minus = (float_type(1) / ex_plus);
|
||||
return (ex_plus - ex_minus) / (ex_plus + ex_minus);
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ASINH(boost::math::cstdfloat::detail::float_internal128_t x) throw()
|
||||
{
|
||||
// Patch the asinh() function since quadmath does not have it.
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
return ::BOOST_CSTDFLOAT_FLOAT128_LOG(x + ::BOOST_CSTDFLOAT_FLOAT128_SQRT((x * x) + float_type(1)));
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ACOSH(boost::math::cstdfloat::detail::float_internal128_t x) throw()
|
||||
{
|
||||
// Patch the acosh() function since quadmath does not have it.
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
const float_type zp(x + float_type(1));
|
||||
const float_type zm(x - float_type(1));
|
||||
|
||||
return ::BOOST_CSTDFLOAT_FLOAT128_LOG(x + (zp * ::BOOST_CSTDFLOAT_FLOAT128_SQRT(zm / zp)));
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATANH(boost::math::cstdfloat::detail::float_internal128_t x) throw()
|
||||
{
|
||||
// Patch the atanh() function since quadmath does not have it.
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
return ( ::BOOST_CSTDFLOAT_FLOAT128_LOG(float_type(1) + x)
|
||||
- ::BOOST_CSTDFLOAT_FLOAT128_LOG(float_type(1) - x)) / 2;
|
||||
}
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TGAMMA(boost::math::cstdfloat::detail::float_internal128_t x) throw()
|
||||
{
|
||||
// Patch the tgammaq() function for a subset of broken GCC compilers
|
||||
// like GCC 4.7, 4.8 on MinGW.
|
||||
typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
|
||||
|
||||
if(x > float_type(0))
|
||||
{
|
||||
return ::BOOST_CSTDFLOAT_FLOAT128_EXP(::BOOST_CSTDFLOAT_FLOAT128_LGAMMA(x));
|
||||
}
|
||||
else if(x < float_type(0))
|
||||
{
|
||||
// For x < 0, compute tgamma(-x) and use the reflection formula.
|
||||
const float_type positive_x = -x;
|
||||
float_type gamma_value = ::BOOST_CSTDFLOAT_FLOAT128_TGAMMA(positive_x);
|
||||
const float_type floor_of_positive_x = ::BOOST_CSTDFLOAT_FLOAT128_FLOOR (positive_x);
|
||||
|
||||
// Take the reflection checks (slightly adapted) from <boost/math/gamma.hpp>.
|
||||
const bool floor_of_z_is_equal_to_z = (positive_x == ::BOOST_CSTDFLOAT_FLOAT128_FLOOR(positive_x));
|
||||
|
||||
BOOST_CONSTEXPR_OR_CONST float_type my_pi = BOOST_FLOAT128_C(3.14159265358979323846264338327950288419716939937511);
|
||||
|
||||
if(floor_of_z_is_equal_to_z)
|
||||
{
|
||||
const bool is_odd = ((boost::int32_t(floor_of_positive_x) % boost::int32_t(2)) != boost::int32_t(0));
|
||||
|
||||
return (is_odd ? -std::numeric_limits<float_type>::infinity()
|
||||
: +std::numeric_limits<float_type>::infinity());
|
||||
}
|
||||
|
||||
const float_type sinpx_value = x * ::BOOST_CSTDFLOAT_FLOAT128_SIN(my_pi * x);
|
||||
|
||||
gamma_value *= sinpx_value;
|
||||
|
||||
const bool result_is_too_large_to_represent = ( (::BOOST_CSTDFLOAT_FLOAT128_FABS(gamma_value) < float_type(1))
|
||||
&& (((std::numeric_limits<float_type>::max)() * ::BOOST_CSTDFLOAT_FLOAT128_FABS(gamma_value)) < my_pi));
|
||||
|
||||
if(result_is_too_large_to_represent)
|
||||
{
|
||||
const bool is_odd = ((boost::int32_t(floor_of_positive_x) % boost::int32_t(2)) != boost::int32_t(0));
|
||||
|
||||
return (is_odd ? -std::numeric_limits<float_type>::infinity()
|
||||
: +std::numeric_limits<float_type>::infinity());
|
||||
}
|
||||
|
||||
gamma_value = -my_pi / gamma_value;
|
||||
|
||||
if((gamma_value > float_type(0)) || (gamma_value < float_type(0)))
|
||||
{
|
||||
return gamma_value;
|
||||
}
|
||||
else
|
||||
{
|
||||
// The value of gamma is too small to represent. Return 0.0 here.
|
||||
return float_type(0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Gamma of zero is complex infinity. Return NaN here.
|
||||
return std::numeric_limits<float_type>::quiet_NaN();
|
||||
}
|
||||
}
|
||||
#endif // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
|
||||
|
||||
// Define the quadruple-precision <cmath> functions in the namespace boost::math::cstdfloat::detail.
|
||||
|
||||
namespace boost { namespace math { namespace cstdfloat { namespace detail {
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t ldexp (boost::math::cstdfloat::detail::float_internal128_t x, int n) { return ::BOOST_CSTDFLOAT_FLOAT128_LDEXP (x, n); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t frexp (boost::math::cstdfloat::detail::float_internal128_t x, int* pn) { return ::BOOST_CSTDFLOAT_FLOAT128_FREXP (x, pn); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t fabs (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_FABS (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t abs (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_FABS (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t floor (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_FLOOR (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t ceil (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_CEIL (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t sqrt (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_SQRT (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t trunc (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TRUNC (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t exp (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_EXP (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t pow (boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t a) { return ::BOOST_CSTDFLOAT_FLOAT128_POW (x, a); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t pow (boost::math::cstdfloat::detail::float_internal128_t x, int a) { return ::BOOST_CSTDFLOAT_FLOAT128_POW (x, boost::math::cstdfloat::detail::float_internal128_t(a)); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t log (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LOG (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t log10 (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LOG10 (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t sin (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_SIN (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t cos (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_COS (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t tan (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TAN (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t asin (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ASIN (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t acos (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ACOS (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t atan (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ATAN (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t sinh (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_SINH (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t cosh (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_COSH (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t tanh (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TANH (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t asinh (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ASINH (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t acosh (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ACOSH (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t atanh (boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ATANH (x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t fmod (boost::math::cstdfloat::detail::float_internal128_t a, boost::math::cstdfloat::detail::float_internal128_t b) { return ::BOOST_CSTDFLOAT_FLOAT128_FMOD (a, b); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t atan2 (boost::math::cstdfloat::detail::float_internal128_t y, boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ATAN2 (y, x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t lgamma(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LGAMMA(x); }
|
||||
inline boost::math::cstdfloat::detail::float_internal128_t tgamma(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TGAMMA(x); }
|
||||
} } } } // boost::math::cstdfloat::detail
|
||||
|
||||
// We will now inject the quadruple-precision <cmath> functions
|
||||
// into the std namespace. This is done via *using* directive.
|
||||
namespace std
|
||||
{
|
||||
using boost::math::cstdfloat::detail::ldexp;
|
||||
using boost::math::cstdfloat::detail::frexp;
|
||||
using boost::math::cstdfloat::detail::fabs;
|
||||
using boost::math::cstdfloat::detail::abs;
|
||||
using boost::math::cstdfloat::detail::floor;
|
||||
using boost::math::cstdfloat::detail::ceil;
|
||||
using boost::math::cstdfloat::detail::sqrt;
|
||||
using boost::math::cstdfloat::detail::trunc;
|
||||
using boost::math::cstdfloat::detail::exp;
|
||||
using boost::math::cstdfloat::detail::pow;
|
||||
using boost::math::cstdfloat::detail::log;
|
||||
using boost::math::cstdfloat::detail::log10;
|
||||
using boost::math::cstdfloat::detail::sin;
|
||||
using boost::math::cstdfloat::detail::cos;
|
||||
using boost::math::cstdfloat::detail::tan;
|
||||
using boost::math::cstdfloat::detail::asin;
|
||||
using boost::math::cstdfloat::detail::acos;
|
||||
using boost::math::cstdfloat::detail::atan;
|
||||
using boost::math::cstdfloat::detail::sinh;
|
||||
using boost::math::cstdfloat::detail::cosh;
|
||||
using boost::math::cstdfloat::detail::tanh;
|
||||
using boost::math::cstdfloat::detail::asinh;
|
||||
using boost::math::cstdfloat::detail::acosh;
|
||||
using boost::math::cstdfloat::detail::atanh;
|
||||
using boost::math::cstdfloat::detail::fmod;
|
||||
using boost::math::cstdfloat::detail::atan2;
|
||||
using boost::math::cstdfloat::detail::lgamma;
|
||||
using boost::math::cstdfloat::detail::tgamma;
|
||||
} // namespace std
|
||||
|
||||
// We will now remove the preprocessor symbols representing quadruple-precision <cmath>
|
||||
// functions from the preprocessor.
|
||||
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_LDEXP
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_FREXP
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_FABS
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_FLOOR
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_CEIL
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_SQRT
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_TRUNC
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_EXP
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_EXPM1
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_POW
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_LOG
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_LOG10
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_SIN
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_COS
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_TAN
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_ASIN
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_ACOS
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_ATAN
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_SINH
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_COSH
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_TANH
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_ASINH
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_ACOSH
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_ATANH
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_FMOD
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_ATAN2
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_LGAMMA
|
||||
#undef BOOST_CSTDFLOAT_FLOAT128_TGAMMA
|
||||
|
||||
#endif // Not BOOST_CSTDFLOAT_NO_LIBQUADMATH_SUPPORT (i.e., the user would like to have libquadmath support)
|
||||
|
||||
#endif // _BOOST_CSTDFLOAT_CMATH_2014_02_15_HPP_
|
||||
@@ -0,0 +1,177 @@
|
||||
/* CHECK.C - Compute parity checks and other stats on decodings. */
|
||||
|
||||
/* Copyright (c) 1995-2012 by Radford M. Neal.
|
||||
*
|
||||
* Permission is granted for anyone to copy, use, modify, and distribute
|
||||
* these programs and accompanying documents for any purpose, provided
|
||||
* this copyright notice is retained and prominently displayed, and note
|
||||
* is made of any changes made to these programs. These programs and
|
||||
* documents are distributed without any warranty, express or implied.
|
||||
* As the programs were written for research purposes only, they have not
|
||||
* been tested to the degree that would be advisable in any important
|
||||
* application. All use of these programs is entirely at the user's own
|
||||
* risk.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "mod2sparse.h"
|
||||
#include "check.h"
|
||||
|
||||
|
||||
|
||||
/* COMPUTE PARITY CHECKS. Returns the number of parity checks violated by
|
||||
dblk. The results of all the parity checks are stored in pchk. */
|
||||
|
||||
int check
|
||||
( mod2sparse *H, /* Parity check matrix */
|
||||
char *dblk, /* Guess for codeword */
|
||||
char *pchk /* Place to store parity checks */
|
||||
)
|
||||
{
|
||||
int M, i, c;
|
||||
|
||||
M = mod2sparse_rows(H);
|
||||
|
||||
mod2sparse_mulvec (H, dblk, pchk);
|
||||
|
||||
c = 0;
|
||||
for (i = 0; i<M; i++)
|
||||
{ c += pchk[i];
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/* COUNT HOW MANY BITS HAVED CHANGED FROM BIT INDICATED BY LIKELIHOOD. The
|
||||
simple decoding based on likelihood ratio is compared to the given decoding.
|
||||
A bit for which the likelihood ratio is exactly one counts as half a
|
||||
change, which explains why the result is a double rather than an int.
|
||||
*/
|
||||
|
||||
double changed
|
||||
( double *lratio, /* Likelihood ratios for bits */
|
||||
char *dblk, /* Candidate decoding */
|
||||
int N /* Number of bits */
|
||||
)
|
||||
{
|
||||
double changed;
|
||||
int j;
|
||||
|
||||
changed = 0;
|
||||
for (j = 0; j<N; j++)
|
||||
{ changed += lratio[j]==1 ? 0.5 : dblk[j] != (lratio[j]>1);
|
||||
}
|
||||
|
||||
return changed;
|
||||
}
|
||||
|
||||
|
||||
/* COMPUTE THE EXPECTED NUMBER OF PARITY CHECK ERRORS. Computes the
|
||||
expected number of parity check errors with respect to the distribution
|
||||
given by the bit probabilities passed, with bits assumed to be independent.
|
||||
*/
|
||||
|
||||
double expected_parity_errors
|
||||
( mod2sparse *H, /* Parity check matrix */
|
||||
double *bpr /* Bit probabilities */
|
||||
)
|
||||
{
|
||||
mod2entry *f;
|
||||
double ee, p;
|
||||
int M, i, j;
|
||||
|
||||
M = mod2sparse_rows(H);
|
||||
|
||||
ee = 0;
|
||||
|
||||
for (i = 0; i<M; i++)
|
||||
{ p = 0;
|
||||
for (f = mod2sparse_first_in_row(H,i);
|
||||
!mod2sparse_at_end(f);
|
||||
f = mod2sparse_next_in_row(f))
|
||||
{ j = mod2sparse_col(f);
|
||||
p = p * (1-bpr[j]) + (1-p) * bpr[j];
|
||||
}
|
||||
ee += p;
|
||||
}
|
||||
|
||||
return ee;
|
||||
}
|
||||
|
||||
|
||||
/* COMPUTE LOG LIKELIHOOD OF A DECODING. */
|
||||
|
||||
double loglikelihood
|
||||
( double *lratio, /* Likelihood ratios for bits */
|
||||
char *bits, /* Bits in decoding */
|
||||
int N /* Length of codeword */
|
||||
)
|
||||
{
|
||||
double ll;
|
||||
int j;
|
||||
|
||||
ll = 0;
|
||||
|
||||
for (j = 0; j<N; j++)
|
||||
{ ll -= bits[j] ? log(1+1/lratio[j]) : log(1+lratio[j]);
|
||||
}
|
||||
|
||||
return ll;
|
||||
}
|
||||
|
||||
|
||||
/* COMPUTE THE EXPECTED LOG LIKELIHOOD BASED ON BIT PROBABILITIES. Computes
|
||||
the expected value of the log likelihood with respect to the distribution
|
||||
given by the bit probabilities passed, with bits assumed to be independent.
|
||||
*/
|
||||
|
||||
double expected_loglikelihood
|
||||
( double *lratio, /* Likelihood ratios for bits */
|
||||
double *bpr, /* Bit probabilities */
|
||||
int N /* Length of codeword */
|
||||
)
|
||||
{
|
||||
double ll;
|
||||
int j;
|
||||
|
||||
ll = 0;
|
||||
|
||||
for (j = 0; j<N; j++)
|
||||
{ if (bpr[j]>0)
|
||||
{ ll -= bpr[j]*log(1+1/lratio[j]);
|
||||
}
|
||||
if (bpr[j]<1)
|
||||
{ ll -= (1-bpr[j])*log(1+lratio[j]);
|
||||
}
|
||||
}
|
||||
|
||||
return ll;
|
||||
}
|
||||
|
||||
|
||||
/* COMPUTE ENTROPY FROM BIT PROBABILITIES. Computes the entropy of the
|
||||
distribution given by the bit probabilities, on the assumption that
|
||||
bits are independent.
|
||||
*/
|
||||
|
||||
double entropy
|
||||
( double *bpr, /* Bit probabilities */
|
||||
int N /* Length of codeword */
|
||||
)
|
||||
{
|
||||
double e;
|
||||
int j;
|
||||
|
||||
e = 0;
|
||||
for (j = 0; j<N; j++)
|
||||
{ if (bpr[j]>0 && bpr[j]<1)
|
||||
{ e -= bpr[j]*log(bpr[j]) + (1-bpr[j])*log(1-bpr[j]);
|
||||
}
|
||||
}
|
||||
|
||||
return e/log(2.0);
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
/*
|
||||
Copyright Rene Rivera 2008-2015
|
||||
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_PREDEF_LIBRARY_STD_H) || defined(BOOST_PREDEF_INTERNAL_GENERATE_TESTS)
|
||||
#ifndef BOOST_PREDEF_LIBRARY_STD_H
|
||||
#define BOOST_PREDEF_LIBRARY_STD_H
|
||||
#endif
|
||||
|
||||
#include <boost/predef/library/std/_prefix.h>
|
||||
|
||||
#include <boost/predef/library/std/cxx.h>
|
||||
#include <boost/predef/library/std/dinkumware.h>
|
||||
#include <boost/predef/library/std/libcomo.h>
|
||||
#include <boost/predef/library/std/modena.h>
|
||||
#include <boost/predef/library/std/msl.h>
|
||||
#include <boost/predef/library/std/roguewave.h>
|
||||
#include <boost/predef/library/std/sgi.h>
|
||||
#include <boost/predef/library/std/stdcpp3.h>
|
||||
#include <boost/predef/library/std/stlport.h>
|
||||
#include <boost/predef/library/std/vacpp.h>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,160 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
// Preprocessed version of "boost/mpl/apply.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename F
|
||||
>
|
||||
struct apply0
|
||||
|
||||
: apply_wrap0<
|
||||
typename lambda<F>::type
|
||||
|
||||
>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
1
|
||||
, apply0
|
||||
, (F )
|
||||
)
|
||||
};
|
||||
|
||||
/// workaround for ETI bug
|
||||
template<>
|
||||
struct apply0<int>
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename F, typename T1
|
||||
>
|
||||
struct apply1
|
||||
|
||||
: apply_wrap1<
|
||||
typename lambda<F>::type
|
||||
, T1
|
||||
>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
2
|
||||
, apply1
|
||||
, (F, T1)
|
||||
)
|
||||
};
|
||||
|
||||
/// workaround for ETI bug
|
||||
template<>
|
||||
struct apply1< int,int >
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2
|
||||
>
|
||||
struct apply2
|
||||
|
||||
: apply_wrap2<
|
||||
typename lambda<F>::type
|
||||
, T1, T2
|
||||
>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
3
|
||||
, apply2
|
||||
, (F, T1, T2)
|
||||
)
|
||||
};
|
||||
|
||||
/// workaround for ETI bug
|
||||
template<>
|
||||
struct apply2< int,int,int >
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3
|
||||
>
|
||||
struct apply3
|
||||
|
||||
: apply_wrap3<
|
||||
typename lambda<F>::type
|
||||
, T1, T2, T3
|
||||
>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
4
|
||||
, apply3
|
||||
, (F, T1, T2, T3)
|
||||
)
|
||||
};
|
||||
|
||||
/// workaround for ETI bug
|
||||
template<>
|
||||
struct apply3< int,int,int,int >
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3, typename T4
|
||||
>
|
||||
struct apply4
|
||||
|
||||
: apply_wrap4<
|
||||
typename lambda<F>::type
|
||||
, T1, T2, T3, T4
|
||||
>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
5
|
||||
, apply4
|
||||
, (F, T1, T2, T3, T4)
|
||||
)
|
||||
};
|
||||
|
||||
/// workaround for ETI bug
|
||||
template<>
|
||||
struct apply4< int,int,int,int,int >
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5
|
||||
>
|
||||
struct apply5
|
||||
|
||||
: apply_wrap5<
|
||||
typename lambda<F>::type
|
||||
, T1, T2, T3, T4, T5
|
||||
>
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(
|
||||
6
|
||||
, apply5
|
||||
, (F, T1, T2, T3, T4, T5)
|
||||
)
|
||||
};
|
||||
|
||||
/// workaround for ETI bug
|
||||
template<>
|
||||
struct apply5< int,int,int,int,int,int >
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
#if !defined(FUSION_VECTOR50_05052005_0207)
|
||||
#define FUSION_VECTOR50_05052005_0207
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/container/vector/detail/cpp03/vector50_fwd.hpp>
|
||||
#include <boost/fusion/support/sequence_base.hpp>
|
||||
#include <boost/fusion/support/is_sequence.hpp>
|
||||
#include <boost/fusion/support/detail/access.hpp>
|
||||
#include <boost/fusion/iterator/next.hpp>
|
||||
#include <boost/fusion/iterator/deref.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/begin.hpp>
|
||||
#include <boost/fusion/container/vector/detail/at_impl.hpp>
|
||||
#include <boost/fusion/container/vector/detail/value_at_impl.hpp>
|
||||
#include <boost/fusion/container/vector/detail/begin_impl.hpp>
|
||||
#include <boost/fusion/container/vector/detail/end_impl.hpp>
|
||||
|
||||
#include <boost/mpl/void.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/at.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/vector/vector50.hpp>
|
||||
#include <boost/type_traits/is_convertible.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
|
||||
#include <boost/preprocessor/dec.hpp>
|
||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_shifted.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
|
||||
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
|
||||
#include <boost/fusion/container/vector/detail/cpp03/preprocessed/vector50.hpp>
|
||||
#else
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/vector50.hpp")
|
||||
#endif
|
||||
|
||||
/*=============================================================================
|
||||
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!
|
||||
==============================================================================*/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct vector_tag;
|
||||
struct fusion_sequence_tag;
|
||||
struct random_access_traversal_tag;
|
||||
|
||||
#define FUSION_HASH #
|
||||
// expand vector41 to vector50
|
||||
#define BOOST_PP_FILENAME_1 <boost/fusion/container/vector/detail/cpp03/vector_n.hpp>
|
||||
#define BOOST_PP_ITERATION_LIMITS (41, 50)
|
||||
#include BOOST_PP_ITERATE()
|
||||
#undef FUSION_HASH
|
||||
}}
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
// Boost.Function library
|
||||
|
||||
// Copyright Douglas Gregor 2002-2003. 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
|
||||
|
||||
#define BOOST_FUNCTION_NUM_ARGS 5
|
||||
#include <boost/function/detail/maybe_include.hpp>
|
||||
#undef BOOST_FUNCTION_NUM_ARGS
|
||||
@@ -0,0 +1,215 @@
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2013-2015 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_PARAMETER_CACHE_HPP
|
||||
#define BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP
|
||||
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/make_shared.hpp>
|
||||
#include <boost/noncopyable.hpp>
|
||||
|
||||
#include <boost/compute/config.hpp>
|
||||
#include <boost/compute/device.hpp>
|
||||
#include <boost/compute/detail/global_static.hpp>
|
||||
#include <boost/compute/version.hpp>
|
||||
|
||||
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
#include <boost/algorithm/string/trim.hpp>
|
||||
#include <boost/compute/detail/path.hpp>
|
||||
#include <boost/property_tree/ptree.hpp>
|
||||
#include <boost/property_tree/json_parser.hpp>
|
||||
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
|
||||
namespace boost {
|
||||
namespace compute {
|
||||
namespace detail {
|
||||
|
||||
class parameter_cache : boost::noncopyable
|
||||
{
|
||||
public:
|
||||
parameter_cache(const device &device)
|
||||
: m_dirty(false),
|
||||
m_device_name(device.name())
|
||||
{
|
||||
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
// get offline cache file name (e.g. /home/user/.boost_compute/tune/device.json)
|
||||
m_file_name = make_file_name();
|
||||
|
||||
// load parameters from offline cache file (if it exists)
|
||||
if(boost::filesystem::exists(m_file_name)){
|
||||
read_from_disk();
|
||||
}
|
||||
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
}
|
||||
|
||||
~parameter_cache()
|
||||
{
|
||||
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
write_to_disk();
|
||||
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
}
|
||||
|
||||
void set(const std::string &object, const std::string ¶meter, uint_ value)
|
||||
{
|
||||
m_cache[std::make_pair(object, parameter)] = value;
|
||||
|
||||
// set the dirty flag to true. this will cause the updated parameters
|
||||
// to be stored to disk.
|
||||
m_dirty = true;
|
||||
}
|
||||
|
||||
uint_ get(const std::string &object, const std::string ¶meter, uint_ default_value)
|
||||
{
|
||||
std::map<std::pair<std::string, std::string>, uint_>::iterator
|
||||
iter = m_cache.find(std::make_pair(object, parameter));
|
||||
if(iter != m_cache.end()){
|
||||
return iter->second;
|
||||
}
|
||||
else {
|
||||
return default_value;
|
||||
}
|
||||
}
|
||||
|
||||
static boost::shared_ptr<parameter_cache> get_global_cache(const device &device)
|
||||
{
|
||||
// device name -> parameter cache
|
||||
typedef std::map<std::string, boost::shared_ptr<parameter_cache> > cache_map;
|
||||
|
||||
BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(cache_map, caches, ((std::less<std::string>())));
|
||||
|
||||
cache_map::iterator iter = caches.find(device.name());
|
||||
if(iter == caches.end()){
|
||||
boost::shared_ptr<parameter_cache> cache =
|
||||
boost::make_shared<parameter_cache>(device);
|
||||
|
||||
caches.insert(iter, std::make_pair(device.name(), cache));
|
||||
|
||||
return cache;
|
||||
}
|
||||
else {
|
||||
return iter->second;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
// returns a string containing a cannoical device name
|
||||
static std::string cannonical_device_name(std::string name)
|
||||
{
|
||||
boost::algorithm::trim(name);
|
||||
std::replace(name.begin(), name.end(), ' ', '_');
|
||||
std::replace(name.begin(), name.end(), '(', '_');
|
||||
std::replace(name.begin(), name.end(), ')', '_');
|
||||
return name;
|
||||
}
|
||||
|
||||
// returns the boost.compute version string
|
||||
static std::string version_string()
|
||||
{
|
||||
char buf[32];
|
||||
std::snprintf(buf, sizeof(buf), "%d.%d.%d", BOOST_COMPUTE_VERSION_MAJOR,
|
||||
BOOST_COMPUTE_VERSION_MINOR,
|
||||
BOOST_COMPUTE_VERSION_PATCH);
|
||||
return buf;
|
||||
}
|
||||
|
||||
// returns the file path for the cached parameters
|
||||
std::string make_file_name() const
|
||||
{
|
||||
return detail::parameter_cache_path(true) + cannonical_device_name(m_device_name) + ".json";
|
||||
}
|
||||
|
||||
// store current parameters to disk
|
||||
void write_to_disk()
|
||||
{
|
||||
BOOST_ASSERT(!m_file_name.empty());
|
||||
|
||||
if(m_dirty){
|
||||
// save current parameters to disk
|
||||
boost::property_tree::ptree pt;
|
||||
pt.put("header.device", m_device_name);
|
||||
pt.put("header.version", version_string());
|
||||
typedef std::map<std::pair<std::string, std::string>, uint_> map_type;
|
||||
for(map_type::const_iterator iter = m_cache.begin(); iter != m_cache.end(); ++iter){
|
||||
const std::pair<std::string, std::string> &key = iter->first;
|
||||
pt.add(key.first + "." + key.second, iter->second);
|
||||
}
|
||||
write_json(m_file_name, pt);
|
||||
|
||||
m_dirty = false;
|
||||
}
|
||||
}
|
||||
|
||||
// load stored parameters from disk
|
||||
void read_from_disk()
|
||||
{
|
||||
BOOST_ASSERT(!m_file_name.empty());
|
||||
|
||||
m_cache.clear();
|
||||
|
||||
boost::property_tree::ptree pt;
|
||||
try {
|
||||
read_json(m_file_name, pt);
|
||||
}
|
||||
catch(boost::property_tree::json_parser::json_parser_error&){
|
||||
// no saved cache file, ignore
|
||||
return;
|
||||
}
|
||||
|
||||
std::string stored_device;
|
||||
try {
|
||||
stored_device = pt.get<std::string>("header.device");
|
||||
}
|
||||
catch(boost::property_tree::ptree_bad_path&){
|
||||
return;
|
||||
}
|
||||
|
||||
std::string stored_version;
|
||||
try {
|
||||
stored_version = pt.get<std::string>("header.version");
|
||||
}
|
||||
catch(boost::property_tree::ptree_bad_path&){
|
||||
return;
|
||||
}
|
||||
|
||||
if(stored_device == m_device_name && stored_version == version_string()){
|
||||
typedef boost::property_tree::ptree::const_iterator pt_iter;
|
||||
for(pt_iter iter = pt.begin(); iter != pt.end(); ++iter){
|
||||
if(iter->first == "header"){
|
||||
// skip header
|
||||
continue;
|
||||
}
|
||||
|
||||
boost::property_tree::ptree child_pt = pt.get_child(iter->first);
|
||||
for(pt_iter child_iter = child_pt.begin(); child_iter != child_pt.end(); ++child_iter){
|
||||
set(iter->first, child_iter->first, boost::lexical_cast<uint_>(child_iter->second.data()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
m_dirty = false;
|
||||
}
|
||||
#endif // BOOST_COMPUTE_USE_OFFLINE_CACHE
|
||||
|
||||
private:
|
||||
bool m_dirty;
|
||||
std::string m_device_name;
|
||||
std::string m_file_name;
|
||||
std::map<std::pair<std::string, std::string>, uint_> m_cache;
|
||||
};
|
||||
|
||||
} // end detail namespace
|
||||
} // end compute namespace
|
||||
} // end boost namespace
|
||||
|
||||
#endif // BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP
|
||||
@@ -0,0 +1,968 @@
|
||||
// Copyright John Maddock 2010, 2012.
|
||||
// Copyright Paul A. Bristow 2011, 2012.
|
||||
|
||||
// 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_CALCULATE_CONSTANTS_CONSTANTS_INCLUDED
|
||||
#define BOOST_MATH_CALCULATE_CONSTANTS_CONSTANTS_INCLUDED
|
||||
|
||||
#include <boost/math/special_functions/trunc.hpp>
|
||||
|
||||
namespace boost{ namespace math{ namespace constants{ namespace detail{
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
|
||||
return ldexp(acos(T(0)), 1);
|
||||
|
||||
/*
|
||||
// Although this code works well, it's usually more accurate to just call acos
|
||||
// and access the number types own representation of PI which is usually calculated
|
||||
// at slightly higher precision...
|
||||
|
||||
T result;
|
||||
T a = 1;
|
||||
T b;
|
||||
T A(a);
|
||||
T B = 0.5f;
|
||||
T D = 0.25f;
|
||||
|
||||
T lim;
|
||||
lim = boost::math::tools::epsilon<T>();
|
||||
|
||||
unsigned k = 1;
|
||||
|
||||
do
|
||||
{
|
||||
result = A + B;
|
||||
result = ldexp(result, -2);
|
||||
b = sqrt(B);
|
||||
a += b;
|
||||
a = ldexp(a, -1);
|
||||
A = a * a;
|
||||
B = A - result;
|
||||
B = ldexp(B, 1);
|
||||
result = A - B;
|
||||
bool neg = boost::math::sign(result) < 0;
|
||||
if(neg)
|
||||
result = -result;
|
||||
if(result <= lim)
|
||||
break;
|
||||
if(neg)
|
||||
result = -result;
|
||||
result = ldexp(result, k - 1);
|
||||
D -= result;
|
||||
++k;
|
||||
lim = ldexp(lim, 1);
|
||||
}
|
||||
while(true);
|
||||
|
||||
result = B / D;
|
||||
return result;
|
||||
*/
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_two_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return 2 * pi<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
template <class T> // 2 / pi
|
||||
template<int N>
|
||||
inline T constant_two_div_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return 2 / pi<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
template <class T> // sqrt(2/pi)
|
||||
template <int N>
|
||||
inline T constant_root_two_div_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt((2 / pi<T, policies::policy<policies::digits2<N> > >()));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_two_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return 1 / two_pi<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(pi<T, policies::policy<policies::digits2<N> > >());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_half_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(pi<T, policies::policy<policies::digits2<N> > >() / 2);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_two_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(two_pi<T, policies::policy<policies::digits2<N> > >());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_log_root_two_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return log(root_two_pi<T, policies::policy<policies::digits2<N> > >());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_ln_four<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(log(static_cast<T>(4)));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_e<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
//
|
||||
// Although we can clearly calculate this from first principles, this hooks into
|
||||
// T's own notion of e, which hopefully will more accurate than one calculated to
|
||||
// a few epsilon:
|
||||
//
|
||||
BOOST_MATH_STD_USING
|
||||
return exp(static_cast<T>(1));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_half<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return static_cast<T>(1) / static_cast<T>(2);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int M>
|
||||
inline T constant_euler<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<M>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
//
|
||||
// This is the method described in:
|
||||
// "Some New Algorithms for High-Precision Computation of Euler's Constant"
|
||||
// Richard P Brent and Edwin M McMillan.
|
||||
// Mathematics of Computation, Volume 34, Number 149, Jan 1980, pages 305-312.
|
||||
// See equation 17 with p = 2.
|
||||
//
|
||||
T n = 3 + (M ? (std::min)(M, tools::digits<T>()) : tools::digits<T>()) / 4;
|
||||
T lim = M ? ldexp(T(1), 1 - (std::min)(M, tools::digits<T>())) : tools::epsilon<T>();
|
||||
T lnn = log(n);
|
||||
T term = 1;
|
||||
T N = -lnn;
|
||||
T D = 1;
|
||||
T Hk = 0;
|
||||
T one = 1;
|
||||
|
||||
for(unsigned k = 1;; ++k)
|
||||
{
|
||||
term *= n * n;
|
||||
term /= k * k;
|
||||
Hk += one / k;
|
||||
N += term * (Hk - lnn);
|
||||
D += term;
|
||||
|
||||
if(term < D * lim)
|
||||
break;
|
||||
}
|
||||
return N / D;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_euler_sqr<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return euler<T, policies::policy<policies::digits2<N> > >()
|
||||
* euler<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_euler<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(1)
|
||||
/ euler<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_two<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(static_cast<T>(2));
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_three<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(static_cast<T>(3));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_half_root_two<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(static_cast<T>(2)) / 2;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_ln_two<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
//
|
||||
// Although there are good ways to calculate this from scratch, this hooks into
|
||||
// T's own notion of log(2) which will hopefully be accurate to the full precision
|
||||
// of T:
|
||||
//
|
||||
BOOST_MATH_STD_USING
|
||||
return log(static_cast<T>(2));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_ln_ten<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return log(static_cast<T>(10));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_ln_ln_two<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return log(log(static_cast<T>(2)));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_third<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(1) / static_cast<T>(3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_twothirds<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(2) / static_cast<T>(3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_two_thirds<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(2) / static_cast<T>(3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_three_quarters<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(3) / static_cast<T>(4);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_pi_minus_three<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return pi<T, policies::policy<policies::digits2<N> > >() - static_cast<T>(3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_four_minus_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return static_cast<T>(4) - pi<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
//template <class T>
|
||||
//template<int N>
|
||||
//inline T constant_pow23_four_minus_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
//{
|
||||
// BOOST_MATH_STD_USING
|
||||
// return pow(four_minus_pi<T, policies::policy<policies::digits2<N> > >(), static_cast<T>(1.5));
|
||||
//}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_exp_minus_half<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return exp(static_cast<T>(-0.5));
|
||||
}
|
||||
|
||||
// Pi
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_root_two<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return static_cast<T>(1) / root_two<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_root_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return static_cast<T>(1) / root_pi<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_root_two_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
return static_cast<T>(1) / root_two_pi<T, policies::policy<policies::digits2<N> > >();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_one_div_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(static_cast<T>(1) / pi<T, policies::policy<policies::digits2<N> > >());
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_four_thirds_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >() * static_cast<T>(4) / static_cast<T>(3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_half_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >() / static_cast<T>(2);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_third_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >() / static_cast<T>(3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_sixth_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >() / static_cast<T>(6);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_two_thirds_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >() * static_cast<T>(2) / static_cast<T>(3);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_three_quarters_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >() * static_cast<T>(3) / static_cast<T>(4);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_pi_pow_e<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pow(pi<T, policies::policy<policies::digits2<N> > >(), e<T, policies::policy<policies::digits2<N> > >()); //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_pi_sqr<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi<T, policies::policy<policies::digits2<N> > >() ; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_pi_sqr_div_six<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi<T, policies::policy<policies::digits2<N> > >()
|
||||
/ static_cast<T>(6); //
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_pi_cubed<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi<T, policies::policy<policies::digits2<N> > >()
|
||||
; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_cbrt_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pow(pi<T, policies::policy<policies::digits2<N> > >(), static_cast<T>(1)/ static_cast<T>(3));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_cbrt_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(1)
|
||||
/ pow(pi<T, policies::policy<policies::digits2<N> > >(), static_cast<T>(1)/ static_cast<T>(3));
|
||||
}
|
||||
|
||||
// Euler's e
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_e_pow_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pow(e<T, policies::policy<policies::digits2<N> > >(), pi<T, policies::policy<policies::digits2<N> > >()); //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_root_e<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sqrt(e<T, policies::policy<policies::digits2<N> > >());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_log10_e<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return log10(e<T, policies::policy<policies::digits2<N> > >());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_log10_e<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(1) /
|
||||
log10(e<T, policies::policy<policies::digits2<N> > >());
|
||||
}
|
||||
|
||||
// Trigonometric
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_degree<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return pi<T, policies::policy<policies::digits2<N> > >()
|
||||
/ static_cast<T>(180)
|
||||
; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_radian<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(180)
|
||||
/ pi<T, policies::policy<policies::digits2<N> > >()
|
||||
; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_sin_one<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sin(static_cast<T>(1)) ; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_cos_one<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return cos(static_cast<T>(1)) ; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_sinh_one<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return sinh(static_cast<T>(1)) ; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_cosh_one<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return cosh(static_cast<T>(1)) ; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_phi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return (static_cast<T>(1) + sqrt(static_cast<T>(5)) )/static_cast<T>(2) ; //
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_ln_phi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
//return log(phi<T, policies::policy<policies::digits2<N> > >()); // ???
|
||||
return log((static_cast<T>(1) + sqrt(static_cast<T>(5)) )/static_cast<T>(2) );
|
||||
}
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_one_div_ln_phi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(1) /
|
||||
log((static_cast<T>(1) + sqrt(static_cast<T>(5)) )/static_cast<T>(2) );
|
||||
}
|
||||
|
||||
// Zeta
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_zeta_two<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
|
||||
return pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi<T, policies::policy<policies::digits2<N> > >()
|
||||
/static_cast<T>(6);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_zeta_three<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
// http://mathworld.wolfram.com/AperysConstant.html
|
||||
// http://en.wikipedia.org/wiki/Mathematical_constant
|
||||
|
||||
// http://oeis.org/A002117/constant
|
||||
//T zeta3("1.20205690315959428539973816151144999076"
|
||||
// "4986292340498881792271555341838205786313"
|
||||
// "09018645587360933525814619915");
|
||||
|
||||
//"1.202056903159594285399738161511449990, 76498629234049888179227155534183820578631309018645587360933525814619915" A002117
|
||||
// 1.202056903159594285399738161511449990, 76498629234049888179227155534183820578631309018645587360933525814619915780, +00);
|
||||
//"1.2020569031595942 double
|
||||
// http://www.spaennare.se/SSPROG/ssnum.pdf // section 11, Algorithm for Apery's constant zeta(3).
|
||||
// Programs to Calculate some Mathematical Constants to Large Precision, Document Version 1.50
|
||||
|
||||
// by Stefan Spannare September 19, 2007
|
||||
// zeta(3) = 1/64 * sum
|
||||
BOOST_MATH_STD_USING
|
||||
T n_fact=static_cast<T>(1); // build n! for n = 0.
|
||||
T sum = static_cast<double>(77); // Start with n = 0 case.
|
||||
// for n = 0, (77/1) /64 = 1.203125
|
||||
//double lim = std::numeric_limits<double>::epsilon();
|
||||
T lim = N ? ldexp(T(1), 1 - (std::min)(N, tools::digits<T>())) : tools::epsilon<T>();
|
||||
for(unsigned int n = 1; n < 40; ++n)
|
||||
{ // three to five decimal digits per term, so 40 should be plenty for 100 decimal digits.
|
||||
//cout << "n = " << n << endl;
|
||||
n_fact *= n; // n!
|
||||
T n_fact_p10 = n_fact * n_fact * n_fact * n_fact * n_fact * n_fact * n_fact * n_fact * n_fact * n_fact; // (n!)^10
|
||||
T num = ((205 * n * n) + (250 * n) + 77) * n_fact_p10; // 205n^2 + 250n + 77
|
||||
// int nn = (2 * n + 1);
|
||||
// T d = factorial(nn); // inline factorial.
|
||||
T d = 1;
|
||||
for(unsigned int i = 1; i <= (n+n + 1); ++i) // (2n + 1)
|
||||
{
|
||||
d *= i;
|
||||
}
|
||||
T den = d * d * d * d * d; // [(2n+1)!]^5
|
||||
//cout << "den = " << den << endl;
|
||||
T term = num/den;
|
||||
if (n % 2 != 0)
|
||||
{ //term *= -1;
|
||||
sum -= term;
|
||||
}
|
||||
else
|
||||
{
|
||||
sum += term;
|
||||
}
|
||||
//cout << "term = " << term << endl;
|
||||
//cout << "sum/64 = " << sum/64 << endl;
|
||||
if(abs(term) < lim)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
return sum / 64;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_catalan<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{ // http://oeis.org/A006752/constant
|
||||
//T c("0.915965594177219015054603514932384110774"
|
||||
//"149374281672134266498119621763019776254769479356512926115106248574");
|
||||
|
||||
// 9.159655941772190150546035149323841107, 74149374281672134266498119621763019776254769479356512926115106248574422619, -01);
|
||||
|
||||
// This is equation (entry) 31 from
|
||||
// http://www-2.cs.cmu.edu/~adamchik/articles/catalan/catalan.htm
|
||||
// See also http://www.mpfr.org/algorithms.pdf
|
||||
BOOST_MATH_STD_USING
|
||||
T k_fact = 1;
|
||||
T tk_fact = 1;
|
||||
T sum = 1;
|
||||
T term;
|
||||
T lim = N ? ldexp(T(1), 1 - (std::min)(N, tools::digits<T>())) : tools::epsilon<T>();
|
||||
|
||||
for(unsigned k = 1;; ++k)
|
||||
{
|
||||
k_fact *= k;
|
||||
tk_fact *= (2 * k) * (2 * k - 1);
|
||||
term = k_fact * k_fact / (tk_fact * (2 * k + 1) * (2 * k + 1));
|
||||
sum += term;
|
||||
if(term < lim)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
return boost::math::constants::pi<T, boost::math::policies::policy<> >()
|
||||
* log(2 + boost::math::constants::root_three<T, boost::math::policies::policy<> >())
|
||||
/ 8
|
||||
+ 3 * sum / 8;
|
||||
}
|
||||
|
||||
namespace khinchin_detail{
|
||||
|
||||
template <class T>
|
||||
T zeta_polynomial_series(T s, T sc, int digits)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
//
|
||||
// This is algorithm 3 from:
|
||||
//
|
||||
// "An Efficient Algorithm for the Riemann Zeta Function", P. Borwein,
|
||||
// Canadian Mathematical Society, Conference Proceedings, 2000.
|
||||
// See: http://www.cecm.sfu.ca/personal/pborwein/PAPERS/P155.pdf
|
||||
//
|
||||
BOOST_MATH_STD_USING
|
||||
int n = (digits * 19) / 53;
|
||||
T sum = 0;
|
||||
T two_n = ldexp(T(1), n);
|
||||
int ej_sign = 1;
|
||||
for(int j = 0; j < n; ++j)
|
||||
{
|
||||
sum += ej_sign * -two_n / pow(T(j + 1), s);
|
||||
ej_sign = -ej_sign;
|
||||
}
|
||||
T ej_sum = 1;
|
||||
T ej_term = 1;
|
||||
for(int j = n; j <= 2 * n - 1; ++j)
|
||||
{
|
||||
sum += ej_sign * (ej_sum - two_n) / pow(T(j + 1), s);
|
||||
ej_sign = -ej_sign;
|
||||
ej_term *= 2 * n - j;
|
||||
ej_term /= j - n + 1;
|
||||
ej_sum += ej_term;
|
||||
}
|
||||
return -sum / (two_n * (1 - pow(T(2), sc)));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
T khinchin(int digits)
|
||||
{
|
||||
BOOST_MATH_STD_USING
|
||||
T sum = 0;
|
||||
T term;
|
||||
T lim = ldexp(T(1), 1-digits);
|
||||
T factor = 0;
|
||||
unsigned last_k = 1;
|
||||
T num = 1;
|
||||
for(unsigned n = 1;; ++n)
|
||||
{
|
||||
for(unsigned k = last_k; k <= 2 * n - 1; ++k)
|
||||
{
|
||||
factor += num / k;
|
||||
num = -num;
|
||||
}
|
||||
last_k = 2 * n;
|
||||
term = (zeta_polynomial_series(T(2 * n), T(1 - T(2 * n)), digits) - 1) * factor / n;
|
||||
sum += term;
|
||||
if(term < lim)
|
||||
break;
|
||||
}
|
||||
return exp(sum / boost::math::constants::ln_two<T, boost::math::policies::policy<> >());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_khinchin<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
int n = N ? (std::min)(N, tools::digits<T>()) : tools::digits<T>();
|
||||
return khinchin_detail::khinchin<T>(n);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_extreme_value_skewness<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{ // from e_float constants.cpp
|
||||
// Mathematica: N[12 Sqrt[6] Zeta[3]/Pi^3, 1101]
|
||||
BOOST_MATH_STD_USING
|
||||
T ev(12 * sqrt(static_cast<T>(6)) * zeta_three<T, policies::policy<policies::digits2<N> > >()
|
||||
/ pi_cubed<T, policies::policy<policies::digits2<N> > >() );
|
||||
|
||||
//T ev(
|
||||
//"1.1395470994046486574927930193898461120875997958365518247216557100852480077060706857071875468869385150"
|
||||
//"1894272048688553376986765366075828644841024041679714157616857834895702411080704529137366329462558680"
|
||||
//"2015498788776135705587959418756809080074611906006528647805347822929577145038743873949415294942796280"
|
||||
//"0895597703063466053535550338267721294164578901640163603544404938283861127819804918174973533694090594"
|
||||
//"3094963822672055237678432023017824416203652657301470473548274848068762500300316769691474974950757965"
|
||||
//"8640779777748741897542093874605477776538884083378029488863880220988107155275203245233994097178778984"
|
||||
//"3488995668362387892097897322246698071290011857605809901090220903955815127463328974447572119951192970"
|
||||
//"3684453635456559086126406960279692862247058250100678008419431185138019869693206366891639436908462809"
|
||||
//"9756051372711251054914491837034685476095423926553367264355374652153595857163724698198860485357368964"
|
||||
//"3807049634423621246870868566707915720704996296083373077647528285782964567312903914752617978405994377"
|
||||
//"9064157147206717895272199736902453130842229559980076472936976287378945035706933650987259357729800315");
|
||||
|
||||
return ev;
|
||||
}
|
||||
|
||||
namespace detail{
|
||||
//
|
||||
// Calculation of the Glaisher constant depends upon calculating the
|
||||
// derivative of the zeta function at 2, we can then use the relation:
|
||||
// zeta'(2) = 1/6 pi^2 [euler + ln(2pi)-12ln(A)]
|
||||
// To get the constant A.
|
||||
// See equation 45 at http://mathworld.wolfram.com/RiemannZetaFunction.html.
|
||||
//
|
||||
// The derivative of the zeta function is computed by direct differentiation
|
||||
// of the relation:
|
||||
// (1-2^(1-s))zeta(s) = SUM(n=0, INF){ (-n)^n / (n+1)^s }
|
||||
// Which gives us 2 slowly converging but alternating sums to compute,
|
||||
// for this we use Algorithm 1 from "Convergent Acceleration of Alternating Series",
|
||||
// Henri Cohen, Fernando Rodriguez Villegas and Don Zagier, Experimental Mathematics 9:1 (1999).
|
||||
// See http://www.math.utexas.edu/users/villegas/publications/conv-accel.pdf
|
||||
//
|
||||
template <class T>
|
||||
T zeta_series_derivative_2(unsigned digits)
|
||||
{
|
||||
// Derivative of the series part, evaluated at 2:
|
||||
BOOST_MATH_STD_USING
|
||||
int n = digits * 301 * 13 / 10000;
|
||||
boost::math::itrunc((std::numeric_limits<T>::digits10 + 1) * 1.3);
|
||||
T d = pow(3 + sqrt(T(8)), n);
|
||||
d = (d + 1 / d) / 2;
|
||||
T b = -1;
|
||||
T c = -d;
|
||||
T s = 0;
|
||||
for(int k = 0; k < n; ++k)
|
||||
{
|
||||
T a = -log(T(k+1)) / ((k+1) * (k+1));
|
||||
c = b - c;
|
||||
s = s + c * a;
|
||||
b = (k + n) * (k - n) * b / ((k + T(0.5f)) * (k + 1));
|
||||
}
|
||||
return s / d;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
T zeta_series_2(unsigned digits)
|
||||
{
|
||||
// Series part of zeta at 2:
|
||||
BOOST_MATH_STD_USING
|
||||
int n = digits * 301 * 13 / 10000;
|
||||
T d = pow(3 + sqrt(T(8)), n);
|
||||
d = (d + 1 / d) / 2;
|
||||
T b = -1;
|
||||
T c = -d;
|
||||
T s = 0;
|
||||
for(int k = 0; k < n; ++k)
|
||||
{
|
||||
T a = T(1) / ((k + 1) * (k + 1));
|
||||
c = b - c;
|
||||
s = s + c * a;
|
||||
b = (k + n) * (k - n) * b / ((k + T(0.5f)) * (k + 1));
|
||||
}
|
||||
return s / d;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T zeta_series_lead_2()
|
||||
{
|
||||
// lead part at 2:
|
||||
return 2;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T zeta_series_derivative_lead_2()
|
||||
{
|
||||
// derivative of lead part at 2:
|
||||
return -2 * boost::math::constants::ln_two<T>();
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T zeta_derivative_2(unsigned n)
|
||||
{
|
||||
// zeta derivative at 2:
|
||||
return zeta_series_derivative_2<T>(n) * zeta_series_lead_2<T>()
|
||||
+ zeta_series_derivative_lead_2<T>() * zeta_series_2<T>(n);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_glaisher<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{
|
||||
|
||||
BOOST_MATH_STD_USING
|
||||
typedef policies::policy<policies::digits2<N> > forwarding_policy;
|
||||
int n = N ? (std::min)(N, tools::digits<T>()) : tools::digits<T>();
|
||||
T v = detail::zeta_derivative_2<T>(n);
|
||||
v *= 6;
|
||||
v /= boost::math::constants::pi<T, forwarding_policy>() * boost::math::constants::pi<T, forwarding_policy>();
|
||||
v -= boost::math::constants::euler<T, forwarding_policy>();
|
||||
v -= log(2 * boost::math::constants::pi<T, forwarding_policy>());
|
||||
v /= -12;
|
||||
return exp(v);
|
||||
|
||||
/*
|
||||
// from http://mpmath.googlecode.com/svn/data/glaisher.txt
|
||||
// 20,000 digits of the Glaisher-Kinkelin constant A = exp(1/2 - zeta'(-1))
|
||||
// Computed using A = exp((6 (-zeta'(2))/pi^2 + log 2 pi + gamma)/12)
|
||||
// with Euler-Maclaurin summation for zeta'(2).
|
||||
T g(
|
||||
"1.282427129100622636875342568869791727767688927325001192063740021740406308858826"
|
||||
"46112973649195820237439420646120399000748933157791362775280404159072573861727522"
|
||||
"14334327143439787335067915257366856907876561146686449997784962754518174312394652"
|
||||
"76128213808180219264516851546143919901083573730703504903888123418813674978133050"
|
||||
"93770833682222494115874837348064399978830070125567001286994157705432053927585405"
|
||||
"81731588155481762970384743250467775147374600031616023046613296342991558095879293"
|
||||
"36343887288701988953460725233184702489001091776941712153569193674967261270398013"
|
||||
"52652668868978218897401729375840750167472114895288815996668743164513890306962645"
|
||||
"59870469543740253099606800842447417554061490189444139386196089129682173528798629"
|
||||
"88434220366989900606980888785849587494085307347117090132667567503310523405221054"
|
||||
"14176776156308191919997185237047761312315374135304725819814797451761027540834943"
|
||||
"14384965234139453373065832325673954957601692256427736926358821692159870775858274"
|
||||
"69575162841550648585890834128227556209547002918593263079373376942077522290940187");
|
||||
|
||||
return g;
|
||||
*/
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_rayleigh_skewness<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{ // From e_float
|
||||
// 1100 digits of the Rayleigh distribution skewness
|
||||
// Mathematica: N[2 Sqrt[Pi] (Pi - 3)/((4 - Pi)^(3/2)), 1100]
|
||||
|
||||
BOOST_MATH_STD_USING
|
||||
T rs(2 * root_pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi_minus_three<T, policies::policy<policies::digits2<N> > >()
|
||||
/ pow(four_minus_pi<T, policies::policy<policies::digits2<N> > >(), static_cast<T>(3./2))
|
||||
);
|
||||
// 6.31110657818937138191899351544227779844042203134719497658094585692926819617473725459905027032537306794400047264,
|
||||
|
||||
//"0.6311106578189371381918993515442277798440422031347194976580945856929268196174737254599050270325373067"
|
||||
//"9440004726436754739597525250317640394102954301685809920213808351450851396781817932734836994829371322"
|
||||
//"5797376021347531983451654130317032832308462278373358624120822253764532674177325950686466133508511968"
|
||||
//"2389168716630349407238090652663422922072397393006683401992961569208109477307776249225072042971818671"
|
||||
//"4058887072693437217879039875871765635655476241624825389439481561152126886932506682176611183750503553"
|
||||
//"1218982627032068396407180216351425758181396562859085306247387212297187006230007438534686340210168288"
|
||||
//"8956816965453815849613622117088096547521391672977226658826566757207615552041767516828171274858145957"
|
||||
//"6137539156656005855905288420585194082284972984285863898582313048515484073396332610565441264220790791"
|
||||
//"0194897267890422924599776483890102027823328602965235306539844007677157873140562950510028206251529523"
|
||||
//"7428049693650605954398446899724157486062545281504433364675815915402937209673727753199567661561209251"
|
||||
//"4695589950526053470201635372590001578503476490223746511106018091907936826431407434894024396366284848"); ;
|
||||
return rs;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_rayleigh_kurtosis_excess<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{ // - (6 Pi^2 - 24 Pi + 16)/((Pi - 4)^2)
|
||||
// Might provide and calculate this using pi_minus_four.
|
||||
BOOST_MATH_STD_USING
|
||||
return - (((static_cast<T>(6) * pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi<T, policies::policy<policies::digits2<N> > >())
|
||||
- (static_cast<T>(24) * pi<T, policies::policy<policies::digits2<N> > >()) + static_cast<T>(16) )
|
||||
/
|
||||
((pi<T, policies::policy<policies::digits2<N> > >() - static_cast<T>(4))
|
||||
* (pi<T, policies::policy<policies::digits2<N> > >() - static_cast<T>(4)))
|
||||
);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
template<int N>
|
||||
inline T constant_rayleigh_kurtosis<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
|
||||
{ // 3 - (6 Pi^2 - 24 Pi + 16)/((Pi - 4)^2)
|
||||
// Might provide and calculate this using pi_minus_four.
|
||||
BOOST_MATH_STD_USING
|
||||
return static_cast<T>(3) - (((static_cast<T>(6) * pi<T, policies::policy<policies::digits2<N> > >()
|
||||
* pi<T, policies::policy<policies::digits2<N> > >())
|
||||
- (static_cast<T>(24) * pi<T, policies::policy<policies::digits2<N> > >()) + static_cast<T>(16) )
|
||||
/
|
||||
((pi<T, policies::policy<policies::digits2<N> > >() - static_cast<T>(4))
|
||||
* (pi<T, policies::policy<policies::digits2<N> > >() - static_cast<T>(4)))
|
||||
);
|
||||
}
|
||||
|
||||
}}}} // namespaces
|
||||
|
||||
#endif // BOOST_MATH_CALCULATE_CONSTANTS_CONSTANTS_INCLUDED
|
||||
@@ -0,0 +1,201 @@
|
||||
# /* Copyright (C) 2001
|
||||
# * Housemarque Oy
|
||||
# * http://www.housemarque.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)
|
||||
# */
|
||||
#
|
||||
# /* Revised by Paul Mensonides (2002-2011) */
|
||||
# /* Revised by Edward Diener (2011,2014) */
|
||||
#
|
||||
# /* See http://www.boost.org for most recent version. */
|
||||
#
|
||||
# ifndef BOOST_PREPROCESSOR_TUPLE_ELEM_HPP
|
||||
# define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP
|
||||
#
|
||||
# include <boost/preprocessor/cat.hpp>
|
||||
# include <boost/preprocessor/config/config.hpp>
|
||||
# include <boost/preprocessor/facilities/expand.hpp>
|
||||
# include <boost/preprocessor/facilities/overload.hpp>
|
||||
# include <boost/preprocessor/tuple/rem.hpp>
|
||||
# include <boost/preprocessor/variadic/elem.hpp>
|
||||
# include <boost/preprocessor/tuple/detail/is_single_return.hpp>
|
||||
#
|
||||
# if BOOST_PP_VARIADICS
|
||||
# if BOOST_PP_VARIADICS_MSVC
|
||||
# define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__), (__VA_ARGS__))
|
||||
# define BOOST_PP_TUPLE_ELEM_I(m, args) BOOST_PP_TUPLE_ELEM_II(m, args)
|
||||
# define BOOST_PP_TUPLE_ELEM_II(m, args) BOOST_PP_CAT(m ## args,)
|
||||
/*
|
||||
Use BOOST_PP_REM_CAT if it is a single element tuple ( which might be empty )
|
||||
else use BOOST_PP_REM. This fixes a VC++ problem with an empty tuple and BOOST_PP_TUPLE_ELEM
|
||||
functionality. See tuple_elem_bug_test.cxx.
|
||||
*/
|
||||
# define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) \
|
||||
BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)) \
|
||||
/**/
|
||||
# else
|
||||
# define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__)
|
||||
# define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
|
||||
# endif
|
||||
# define BOOST_PP_TUPLE_ELEM_O_3(size, n, tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple)
|
||||
# else
|
||||
# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
|
||||
# define BOOST_PP_TUPLE_ELEM(size, n, tuple) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_, n), BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_E_, size), tuple))
|
||||
# define BOOST_PP_TUPLE_ELEM_I(m, args) BOOST_PP_TUPLE_ELEM_II(m, args)
|
||||
# define BOOST_PP_TUPLE_ELEM_II(m, args) BOOST_PP_CAT(m ## args,)
|
||||
# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
|
||||
# define BOOST_PP_TUPLE_ELEM(size, n, tuple) BOOST_PP_TUPLE_ELEM_I_OO((size, n, tuple))
|
||||
# define BOOST_PP_TUPLE_ELEM_I_OO(par) BOOST_PP_TUPLE_ELEM_I ## par
|
||||
# define BOOST_PP_TUPLE_ELEM_I(size, n, tuple) BOOST_PP_TUPLE_ELEM_II((n, BOOST_PP_TUPLE_ELEM_E_ ## size ## tuple))
|
||||
# define BOOST_PP_TUPLE_ELEM_II(par) BOOST_PP_TUPLE_ELEM_III_OO(par)
|
||||
# define BOOST_PP_TUPLE_ELEM_III_OO(par) BOOST_PP_TUPLE_ELEM_III ## par
|
||||
# define BOOST_PP_TUPLE_ELEM_III(n, etuple) BOOST_PP_TUPLE_ELEM_ ## n ## etuple
|
||||
# else
|
||||
# define BOOST_PP_TUPLE_ELEM(size, n, tuple) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_, n) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM_E_, size) tuple)
|
||||
# define BOOST_PP_TUPLE_ELEM_I(x) x
|
||||
# endif
|
||||
# define BOOST_PP_TUPLE_ELEM_E_1(e0) (e0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_2(e0, e1) (e0, e1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_3(e0, e1, e2) (e0, e1, e2, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_4(e0, e1, e2, e3) (e0, e1, e2, e3, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_5(e0, e1, e2, e3, e4) (e0, e1, e2, e3, e4, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_6(e0, e1, e2, e3, e4, e5) (e0, e1, e2, e3, e4, e5, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_7(e0, e1, e2, e3, e4, e5, e6) (e0, e1, e2, e3, e4, e5, e6, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_8(e0, e1, e2, e3, e4, e5, e6, e7) (e0, e1, e2, e3, e4, e5, e6, e7, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_9(e0, e1, e2, e3, e4, e5, e6, e7, e8) (e0, e1, e2, e3, e4, e5, e6, e7, e8, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, ?, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, ?, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, ?, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, ?, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, ?, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, ?, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62) (e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, ?)
|
||||
# define BOOST_PP_TUPLE_ELEM_E_64
|
||||
# define BOOST_PP_TUPLE_ELEM_0(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e0
|
||||
# define BOOST_PP_TUPLE_ELEM_1(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e1
|
||||
# define BOOST_PP_TUPLE_ELEM_2(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e2
|
||||
# define BOOST_PP_TUPLE_ELEM_3(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e3
|
||||
# define BOOST_PP_TUPLE_ELEM_4(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e4
|
||||
# define BOOST_PP_TUPLE_ELEM_5(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e5
|
||||
# define BOOST_PP_TUPLE_ELEM_6(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e6
|
||||
# define BOOST_PP_TUPLE_ELEM_7(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e7
|
||||
# define BOOST_PP_TUPLE_ELEM_8(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e8
|
||||
# define BOOST_PP_TUPLE_ELEM_9(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e9
|
||||
# define BOOST_PP_TUPLE_ELEM_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e10
|
||||
# define BOOST_PP_TUPLE_ELEM_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e11
|
||||
# define BOOST_PP_TUPLE_ELEM_12(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e12
|
||||
# define BOOST_PP_TUPLE_ELEM_13(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e13
|
||||
# define BOOST_PP_TUPLE_ELEM_14(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e14
|
||||
# define BOOST_PP_TUPLE_ELEM_15(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e15
|
||||
# define BOOST_PP_TUPLE_ELEM_16(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e16
|
||||
# define BOOST_PP_TUPLE_ELEM_17(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e17
|
||||
# define BOOST_PP_TUPLE_ELEM_18(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e18
|
||||
# define BOOST_PP_TUPLE_ELEM_19(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e19
|
||||
# define BOOST_PP_TUPLE_ELEM_20(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e20
|
||||
# define BOOST_PP_TUPLE_ELEM_21(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e21
|
||||
# define BOOST_PP_TUPLE_ELEM_22(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e22
|
||||
# define BOOST_PP_TUPLE_ELEM_23(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e23
|
||||
# define BOOST_PP_TUPLE_ELEM_24(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e24
|
||||
# define BOOST_PP_TUPLE_ELEM_25(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e25
|
||||
# define BOOST_PP_TUPLE_ELEM_26(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e26
|
||||
# define BOOST_PP_TUPLE_ELEM_27(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e27
|
||||
# define BOOST_PP_TUPLE_ELEM_28(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e28
|
||||
# define BOOST_PP_TUPLE_ELEM_29(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e29
|
||||
# define BOOST_PP_TUPLE_ELEM_30(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e30
|
||||
# define BOOST_PP_TUPLE_ELEM_31(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e31
|
||||
# define BOOST_PP_TUPLE_ELEM_32(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e32
|
||||
# define BOOST_PP_TUPLE_ELEM_33(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e33
|
||||
# define BOOST_PP_TUPLE_ELEM_34(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e34
|
||||
# define BOOST_PP_TUPLE_ELEM_35(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e35
|
||||
# define BOOST_PP_TUPLE_ELEM_36(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e36
|
||||
# define BOOST_PP_TUPLE_ELEM_37(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e37
|
||||
# define BOOST_PP_TUPLE_ELEM_38(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e38
|
||||
# define BOOST_PP_TUPLE_ELEM_39(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e39
|
||||
# define BOOST_PP_TUPLE_ELEM_40(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e40
|
||||
# define BOOST_PP_TUPLE_ELEM_41(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e41
|
||||
# define BOOST_PP_TUPLE_ELEM_42(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e42
|
||||
# define BOOST_PP_TUPLE_ELEM_43(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e43
|
||||
# define BOOST_PP_TUPLE_ELEM_44(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e44
|
||||
# define BOOST_PP_TUPLE_ELEM_45(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e45
|
||||
# define BOOST_PP_TUPLE_ELEM_46(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e46
|
||||
# define BOOST_PP_TUPLE_ELEM_47(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e47
|
||||
# define BOOST_PP_TUPLE_ELEM_48(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e48
|
||||
# define BOOST_PP_TUPLE_ELEM_49(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e49
|
||||
# define BOOST_PP_TUPLE_ELEM_50(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e50
|
||||
# define BOOST_PP_TUPLE_ELEM_51(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e51
|
||||
# define BOOST_PP_TUPLE_ELEM_52(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e52
|
||||
# define BOOST_PP_TUPLE_ELEM_53(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e53
|
||||
# define BOOST_PP_TUPLE_ELEM_54(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e54
|
||||
# define BOOST_PP_TUPLE_ELEM_55(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e55
|
||||
# define BOOST_PP_TUPLE_ELEM_56(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e56
|
||||
# define BOOST_PP_TUPLE_ELEM_57(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e57
|
||||
# define BOOST_PP_TUPLE_ELEM_58(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e58
|
||||
# define BOOST_PP_TUPLE_ELEM_59(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e59
|
||||
# define BOOST_PP_TUPLE_ELEM_60(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e60
|
||||
# define BOOST_PP_TUPLE_ELEM_61(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e61
|
||||
# define BOOST_PP_TUPLE_ELEM_62(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e62
|
||||
# define BOOST_PP_TUPLE_ELEM_63(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63) e63
|
||||
# endif
|
||||
#
|
||||
# /* directly used elsewhere in Boost... */
|
||||
#
|
||||
# define BOOST_PP_TUPLE_ELEM_1_0(a) a
|
||||
#
|
||||
# define BOOST_PP_TUPLE_ELEM_2_0(a, b) a
|
||||
# define BOOST_PP_TUPLE_ELEM_2_1(a, b) b
|
||||
#
|
||||
# define BOOST_PP_TUPLE_ELEM_3_0(a, b, c) a
|
||||
# define BOOST_PP_TUPLE_ELEM_3_1(a, b, c) b
|
||||
# define BOOST_PP_TUPLE_ELEM_3_2(a, b, c) c
|
||||
#
|
||||
# endif
|
||||
@@ -0,0 +1,124 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// basic_binary_oprimitive.ipp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <ostream>
|
||||
#include <cstddef> // NULL
|
||||
#include <cstring>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
|
||||
namespace std{
|
||||
using ::strlen;
|
||||
} // namespace std
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
#include <cwchar>
|
||||
#ifdef BOOST_NO_STDC_NAMESPACE
|
||||
namespace std{ using ::wcslen; }
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <boost/archive/basic_binary_oprimitive.hpp>
|
||||
#include <boost/core/no_exceptions_support.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// implementation of basic_binary_oprimitive
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::init()
|
||||
{
|
||||
// record native sizes of fundamental types
|
||||
// this is to permit detection of attempts to pass
|
||||
// native binary archives accross incompatible machines.
|
||||
// This is not foolproof but its better than nothing.
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(int)));
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(long)));
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(float)));
|
||||
this->This()->save(static_cast<unsigned char>(sizeof(double)));
|
||||
// for checking endianness
|
||||
this->This()->save(int(1));
|
||||
}
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
|
||||
{
|
||||
std::size_t l = std::strlen(s);
|
||||
this->This()->save(l);
|
||||
save_binary(s, l);
|
||||
}
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
|
||||
{
|
||||
std::size_t l = static_cast<std::size_t>(s.size());
|
||||
this->This()->save(l);
|
||||
save_binary(s.data(), l);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_CWCHAR
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
|
||||
{
|
||||
std::size_t l = std::wcslen(ws);
|
||||
this->This()->save(l);
|
||||
save_binary(ws, l * sizeof(wchar_t) / sizeof(char));
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
|
||||
{
|
||||
std::size_t l = ws.size();
|
||||
this->This()->save(l);
|
||||
save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
|
||||
std::basic_streambuf<Elem, Tr> & sb,
|
||||
bool no_codecvt
|
||||
) :
|
||||
#ifndef BOOST_NO_STD_LOCALE
|
||||
m_sb(sb),
|
||||
codecvt_null_facet(1),
|
||||
locale_saver(m_sb),
|
||||
archive_locale(sb.getloc(), & codecvt_null_facet)
|
||||
{
|
||||
if(! no_codecvt){
|
||||
m_sb.pubsync();
|
||||
m_sb.pubimbue(archive_locale);
|
||||
}
|
||||
}
|
||||
#else
|
||||
m_sb(sb)
|
||||
{}
|
||||
#endif
|
||||
|
||||
// scoped_ptr requires that g be a complete type at time of
|
||||
// destruction so define destructor here rather than in the header
|
||||
template<class Archive, class Elem, class Tr>
|
||||
BOOST_ARCHIVE_OR_WARCHIVE_DECL
|
||||
basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){}
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
@@ -0,0 +1,29 @@
|
||||
# /* **************************************************************************
|
||||
# * *
|
||||
# * (C) Copyright Paul Mensonides 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)
|
||||
# * *
|
||||
# ************************************************************************** */
|
||||
#
|
||||
# /* See http://www.boost.org for most recent version. */
|
||||
#
|
||||
# ifndef BOOST_PREPROCESSOR_SEQ_REMOVE_HPP
|
||||
# define BOOST_PREPROCESSOR_SEQ_REMOVE_HPP
|
||||
#
|
||||
# include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
# include <boost/preprocessor/config/config.hpp>
|
||||
# include <boost/preprocessor/seq/first_n.hpp>
|
||||
# include <boost/preprocessor/seq/rest_n.hpp>
|
||||
#
|
||||
# /* BOOST_PP_SEQ_REMOVE */
|
||||
#
|
||||
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
|
||||
# define BOOST_PP_SEQ_REMOVE(seq, i) BOOST_PP_SEQ_FIRST_N(i, seq) BOOST_PP_SEQ_REST_N(BOOST_PP_INC(i), seq)
|
||||
# else
|
||||
# define BOOST_PP_SEQ_REMOVE(seq, i) BOOST_PP_SEQ_REMOVE_I(seq, i)
|
||||
# define BOOST_PP_SEQ_REMOVE_I(seq, i) BOOST_PP_SEQ_FIRST_N(i, seq) BOOST_PP_SEQ_REST_N(BOOST_PP_INC(i), seq)
|
||||
# endif
|
||||
#
|
||||
# endif
|
||||
@@ -0,0 +1,14 @@
|
||||
// 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 CONVERTIBLE_FUNCTION_DWA200278_HPP
|
||||
# define CONVERTIBLE_FUNCTION_DWA200278_HPP
|
||||
|
||||
namespace boost { namespace python { namespace converter {
|
||||
|
||||
typedef void* (*convertible_function)(PyObject*);
|
||||
|
||||
}}} // namespace boost::python::converter
|
||||
|
||||
#endif // CONVERTIBLE_FUNCTION_DWA200278_HPP
|
||||
@@ -0,0 +1,51 @@
|
||||
<HTML><HEAD>
|
||||
|
||||
<TITLE> Modulo-2 Matrix Sparse/Dense Conversion </TITLE>
|
||||
|
||||
</HEAD><BODY>
|
||||
|
||||
|
||||
<H1> Modulo-2 Matrix Sparse/Dense Conversion </H1>
|
||||
|
||||
<P>The routines below convert modulo-2 matrices between the form used by
|
||||
the <A HREF="mod2dense.html">routines for dense modulo-2 matrices</A>
|
||||
and the form used by the <A HREF="mod2dense.html">routines for sparse
|
||||
modulo-2 matrices</A>.
|
||||
|
||||
<P><B>Header files required</B>:
|
||||
<TT>mod2sparse.h mod2dense.h mod2convert.h</TT>
|
||||
|
||||
|
||||
<P><A NAME="sparse_to_dense"><HR><B>mod2sparse_to_dense</B>:
|
||||
Convert a modulo-2 matrix from sparse to dense form.</A>
|
||||
|
||||
<BLOCKQUOTE><PRE>
|
||||
void mod2sparse_to_dense
|
||||
( mod2sparse *m, /* Sparse matrix to convert */
|
||||
mod2dense *r /* Place to store result */
|
||||
)
|
||||
</PRE></BLOCKQUOTE>
|
||||
|
||||
The dense matrix, r, must already have been allocated, and must have at
|
||||
least as many rows and columns as m, the sparse matrix to be converted.
|
||||
|
||||
|
||||
<P><A NAME="dense_to_sparse"><HR><B>mod2dense_to_sparse</B>:
|
||||
Convert a modulo-2 matrix from dense to sparse form.</A>
|
||||
|
||||
<BLOCKQUOTE><PRE>
|
||||
void mod2dense_to_sparse
|
||||
( mod2dense *m, /* Dense matrix to convert */
|
||||
mod2sparse *r /* Place to store result */
|
||||
)
|
||||
</PRE></BLOCKQUOTE>
|
||||
|
||||
The sparse matrix, r, must already have been allocated, and must have at
|
||||
least as many rows and columns as m, the dense matrix to be converted.
|
||||
|
||||
|
||||
<HR>
|
||||
|
||||
<A HREF="index.html">Back to index for LDPC software</A>
|
||||
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,24 @@
|
||||
|
||||
#ifndef BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED
|
||||
#define BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2003-2004
|
||||
// Copyright David Abrahams 2003-2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org/libs/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
namespace boost { namespace mpl { namespace aux {
|
||||
|
||||
struct set_tag;
|
||||
|
||||
}}}
|
||||
|
||||
#endif // BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED
|
||||
@@ -0,0 +1,224 @@
|
||||
#ifndef BOOST_ARCHIVE_DINKUMWARE_HPP
|
||||
#define BOOST_ARCHIVE_DINKUMWARE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// dinkumware.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
// this file adds a couple of things that are missing from the dinkumware
|
||||
// implementation of the standard library.
|
||||
|
||||
#include <iterator>
|
||||
#include <string>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
namespace std {
|
||||
|
||||
// define i/o operators for 64 bit integers
|
||||
template<class CharType>
|
||||
basic_ostream<CharType> &
|
||||
operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
|
||||
// octal rendering of 64 bit number would be 22 octets + eos
|
||||
CharType d[23];
|
||||
unsigned int radix;
|
||||
|
||||
if(os.flags() & (int)std::ios_base::hex)
|
||||
radix = 16;
|
||||
else
|
||||
if(os.flags() & (int)std::ios_base::oct)
|
||||
radix = 8;
|
||||
else
|
||||
//if(s.flags() & (int)std::ios_base::dec)
|
||||
radix = 10;
|
||||
unsigned int i = 0;
|
||||
do{
|
||||
unsigned int j = t % radix;
|
||||
d[i++] = j + ((j < 10) ? '0' : ('a' - 10));
|
||||
t /= radix;
|
||||
}
|
||||
while(t > 0);
|
||||
d[i--] = '\0';
|
||||
|
||||
// reverse digits
|
||||
unsigned int j = 0;
|
||||
while(j < i){
|
||||
CharType k = d[i];
|
||||
d[i] = d[j];
|
||||
d[j] = k;
|
||||
--i;++j;
|
||||
}
|
||||
os << d;
|
||||
return os;
|
||||
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
basic_ostream<CharType> &
|
||||
operator<<(basic_ostream<CharType> &os, boost::int64_t t){
|
||||
if(0 <= t){
|
||||
os << static_cast<boost::uint64_t>(t);
|
||||
}
|
||||
else{
|
||||
os.put('-');
|
||||
os << -t;
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
basic_istream<CharType> &
|
||||
operator>>(basic_istream<CharType> &is, boost::int64_t & t){
|
||||
CharType d;
|
||||
do{
|
||||
d = is.get();
|
||||
}
|
||||
while(::isspace(d));
|
||||
bool negative = (d == '-');
|
||||
if(negative)
|
||||
d = is.get();
|
||||
unsigned int radix;
|
||||
if(is.flags() & (int)std::ios_base::hex)
|
||||
radix = 16;
|
||||
else
|
||||
if(is.flags() & (int)std::ios_base::oct)
|
||||
radix = 8;
|
||||
else
|
||||
//if(s.flags() & (int)std::ios_base::dec)
|
||||
radix = 10;
|
||||
t = 0;
|
||||
do{
|
||||
if('0' <= d && d <= '9')
|
||||
t = t * radix + (d - '0');
|
||||
else
|
||||
if('a' <= d && d <= 'f')
|
||||
t = t * radix + (d - 'a' + 10);
|
||||
else
|
||||
break;
|
||||
d = is.get();
|
||||
}
|
||||
while(!is.fail());
|
||||
// restore the delimiter
|
||||
is.putback(d);
|
||||
is.clear();
|
||||
if(negative)
|
||||
t = -t;
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class CharType>
|
||||
basic_istream<CharType> &
|
||||
operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
|
||||
boost::int64_t it;
|
||||
is >> it;
|
||||
t = it;
|
||||
return is;
|
||||
}
|
||||
|
||||
//#endif
|
||||
|
||||
template<>
|
||||
class back_insert_iterator<basic_string<char> > : public
|
||||
iterator<output_iterator_tag, char>
|
||||
{
|
||||
public:
|
||||
typedef basic_string<char> container_type;
|
||||
typedef container_type::reference reference;
|
||||
|
||||
explicit back_insert_iterator(container_type & s)
|
||||
: container(& s)
|
||||
{} // construct with container
|
||||
|
||||
back_insert_iterator<container_type> & operator=(
|
||||
container_type::const_reference Val_
|
||||
){ // push value into container
|
||||
//container->push_back(Val_);
|
||||
*container += Val_;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator*(){
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator++(){
|
||||
// pretend to preincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> operator++(int){
|
||||
// pretend to postincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
protected:
|
||||
container_type *container; // pointer to container
|
||||
};
|
||||
|
||||
template<char>
|
||||
inline back_insert_iterator<basic_string<char> > back_inserter(
|
||||
basic_string<char> & s
|
||||
){
|
||||
return (std::back_insert_iterator<basic_string<char> >(s));
|
||||
}
|
||||
|
||||
template<>
|
||||
class back_insert_iterator<basic_string<wchar_t> > : public
|
||||
iterator<output_iterator_tag, wchar_t>
|
||||
{
|
||||
public:
|
||||
typedef basic_string<wchar_t> container_type;
|
||||
typedef container_type::reference reference;
|
||||
|
||||
explicit back_insert_iterator(container_type & s)
|
||||
: container(& s)
|
||||
{} // construct with container
|
||||
|
||||
back_insert_iterator<container_type> & operator=(
|
||||
container_type::const_reference Val_
|
||||
){ // push value into container
|
||||
//container->push_back(Val_);
|
||||
*container += Val_;
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator*(){
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> & operator++(){
|
||||
// pretend to preincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
back_insert_iterator<container_type> operator++(int){
|
||||
// pretend to postincrement
|
||||
return (*this);
|
||||
}
|
||||
|
||||
protected:
|
||||
container_type *container; // pointer to container
|
||||
};
|
||||
|
||||
template<wchar_t>
|
||||
inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
|
||||
basic_string<wchar_t> & s
|
||||
){
|
||||
return (std::back_insert_iterator<basic_string<wchar_t> >(s));
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif //BOOST_ARCHIVE_DINKUMWARE_HPP
|
||||
Reference in New Issue
Block a user