Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,15 @@
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// abi_suffix.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.
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
|
||||
// (C) Copyright Tobias Schwinger
|
||||
//
|
||||
// Use modification and distribution are subject to the boost Software License,
|
||||
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_FT_IS_FUNCTION_REFERENCE_HPP_INCLUDED
|
||||
#define BOOST_FT_IS_FUNCTION_REFERENCE_HPP_INCLUDED
|
||||
|
||||
#include <boost/mpl/aux_/lambda_support.hpp>
|
||||
|
||||
#include <boost/function_types/components.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace function_types
|
||||
{
|
||||
template< typename T, typename Tag = null_tag >
|
||||
struct is_function_reference
|
||||
: function_types::represents
|
||||
< function_types::components<T>
|
||||
, function_types::tag<Tag ,detail::reference_tag> >
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_function_reference,(T,Tag))
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
|
||||
// unit/quantity manipulation and conversion
|
||||
//
|
||||
// Copyright (C) 2003-2008 Matthias Christian Schabel
|
||||
// Copyright (C) 2008 Steven Watanabe
|
||||
//
|
||||
// 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_UNITS_DETAIL_SORT_HPP
|
||||
#define BOOST_UNITS_DETAIL_SORT_HPP
|
||||
|
||||
#include <boost/mpl/size.hpp>
|
||||
#include <boost/mpl/begin.hpp>
|
||||
#include <boost/mpl/next.hpp>
|
||||
#include <boost/mpl/deref.hpp>
|
||||
#include <boost/mpl/push_front.hpp>
|
||||
#include <boost/mpl/less.hpp>
|
||||
|
||||
#include <boost/units/dimensionless_type.hpp>
|
||||
#include <boost/units/detail/dimension_list.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<int N>
|
||||
struct insertion_sort_insert;
|
||||
|
||||
template<bool is_greater>
|
||||
struct insertion_sort_comparison_impl;
|
||||
|
||||
// have to recursively add the element to the next sequence.
|
||||
template<>
|
||||
struct insertion_sort_comparison_impl<true> {
|
||||
template<class Begin, int N, class T>
|
||||
struct apply {
|
||||
typedef list<
|
||||
typename Begin::item,
|
||||
typename insertion_sort_insert<N - 1>::template apply<
|
||||
typename Begin::next,
|
||||
T
|
||||
>::type
|
||||
> type;
|
||||
};
|
||||
};
|
||||
|
||||
// prepend the current element
|
||||
template<>
|
||||
struct insertion_sort_comparison_impl<false> {
|
||||
template<class Begin, int N, class T>
|
||||
struct apply {
|
||||
typedef list<T, Begin> type;
|
||||
};
|
||||
};
|
||||
|
||||
template<int N>
|
||||
struct insertion_sort_insert {
|
||||
template<class Begin, class T>
|
||||
struct apply {
|
||||
typedef typename insertion_sort_comparison_impl<mpl::less<typename Begin::item, T>::value>::template apply<
|
||||
Begin,
|
||||
N,
|
||||
T
|
||||
>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct insertion_sort_insert<0> {
|
||||
template<class Begin, class T>
|
||||
struct apply {
|
||||
typedef list<T, dimensionless_type> type;
|
||||
};
|
||||
};
|
||||
|
||||
template<int N>
|
||||
struct insertion_sort_impl {
|
||||
template<class Begin>
|
||||
struct apply {
|
||||
typedef typename insertion_sort_impl<N - 1>::template apply<typename Begin::next>::type next;
|
||||
typedef typename insertion_sort_insert<(next::size::value)>::template apply<next, typename Begin::item>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<>
|
||||
struct insertion_sort_impl<0> {
|
||||
template<class Begin>
|
||||
struct apply {
|
||||
typedef dimensionless_type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct insertion_sort
|
||||
{
|
||||
typedef typename insertion_sort_impl<T::size::value>::template apply<T>::type type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,166 @@
|
||||
/* ALIST-TO-PCHK.C - Convert a parity check matrix to alist format. */
|
||||
|
||||
/* 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 <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "alloc.h"
|
||||
#include "open.h"
|
||||
#include "mod2sparse.h"
|
||||
#include "mod2dense.h"
|
||||
#include "mod2convert.h"
|
||||
#include "rcode.h"
|
||||
|
||||
|
||||
void usage(void);
|
||||
|
||||
|
||||
/* MAIN PROGRAM. */
|
||||
|
||||
int main
|
||||
( int argc,
|
||||
char **argv
|
||||
)
|
||||
{
|
||||
char *alist_file, *pchk_file;
|
||||
FILE *af, *pf;
|
||||
int mxrw, mxcw;
|
||||
int *rw, *cw;
|
||||
int i, j, k;
|
||||
mod2entry *e;
|
||||
int trans;
|
||||
int nozeros;
|
||||
int last;
|
||||
|
||||
trans = 0;
|
||||
nozeros = 0;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if (argc>1 && strcmp(argv[1],"-t")==0)
|
||||
{ trans = 1;
|
||||
argc -= 1;
|
||||
argv += 1;
|
||||
}
|
||||
else if (argc>1 && strcmp(argv[1],"-z")==0)
|
||||
{ nozeros = 1;
|
||||
argc -= 1;
|
||||
argv += 1;
|
||||
}
|
||||
else
|
||||
{ break;
|
||||
}
|
||||
}
|
||||
|
||||
if (argc!=3)
|
||||
{ usage();
|
||||
}
|
||||
|
||||
pchk_file = argv[1];
|
||||
alist_file = argv[2];
|
||||
|
||||
read_pchk(pchk_file);
|
||||
|
||||
if (trans)
|
||||
{ mod2sparse *HT;
|
||||
HT = H;
|
||||
H = mod2sparse_allocate(N,M);
|
||||
mod2sparse_transpose(HT,H);
|
||||
M = mod2sparse_rows(H);
|
||||
N = mod2sparse_cols(H);
|
||||
}
|
||||
|
||||
af = open_file_std(alist_file,"wb");
|
||||
|
||||
if (af==NULL)
|
||||
{ fprintf(stderr,"Can't create alist file: %s\n",alist_file);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
fprintf(af,"%d %d\n",M,N);
|
||||
|
||||
rw = (int *) chk_alloc (M, sizeof *rw);
|
||||
mxrw = 0;
|
||||
|
||||
for (i = 0; i<M; i++)
|
||||
{ rw[i] = mod2sparse_count_row(H,i);
|
||||
if (rw[i]>mxrw)
|
||||
{ mxrw = rw[i];
|
||||
}
|
||||
}
|
||||
|
||||
cw = (int *) chk_alloc (N, sizeof *cw);
|
||||
mxcw = 0;
|
||||
|
||||
for (j = 0; j<N; j++)
|
||||
{ cw[j] = mod2sparse_count_col(H,j);
|
||||
if (cw[j]>mxcw)
|
||||
{ mxcw = cw[j];
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(af,"%d %d\n",mxrw,mxcw);
|
||||
|
||||
for (i = 0; i<M; i++)
|
||||
{ fprintf(af,"%d%c",rw[i],i==M-1?'\n':' ');
|
||||
}
|
||||
|
||||
for (j = 0; j<N; j++)
|
||||
{ fprintf(af,"%d%c",cw[j],j==N-1?'\n':' ');
|
||||
}
|
||||
|
||||
for (i = 0; i<M; i++)
|
||||
{ e = mod2sparse_first_in_row(H,i);
|
||||
last = 0;
|
||||
for (k = 0; !last; k++)
|
||||
{ last = nozeros ? k==rw[i]-1 : k==mxrw-1;
|
||||
fprintf (af, "%d%c", mod2sparse_at_end(e)?0:mod2sparse_col(e)+1,
|
||||
last?'\n':' ');
|
||||
if (!mod2sparse_at_end(e))
|
||||
{ e = mod2sparse_next_in_row(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (j = 0; j<N; j++)
|
||||
{ e = mod2sparse_first_in_col(H,j);
|
||||
last = 0;
|
||||
for (k = 0; !last; k++)
|
||||
{ last = nozeros ? k==cw[j]-1 : k==mxcw-1;
|
||||
fprintf (af, "%d%c", mod2sparse_at_end(e)?0:mod2sparse_row(e)+1,
|
||||
last?'\n':' ');
|
||||
if (!mod2sparse_at_end(e))
|
||||
{ e = mod2sparse_next_in_col(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ferror(af) || fclose(af)!=0)
|
||||
{ fprintf(stderr,"Error writing to alist file %s\n",alist_file);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* PRINT USAGE MESSAGE AND EXIT. */
|
||||
|
||||
void usage(void)
|
||||
{ fprintf(stderr,"Usage: pchk-to-alist [ -t ] [ -z ] pchk-file alist-file\n");
|
||||
exit(1);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,249 @@
|
||||
/* Copyright 2003-2015 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_INDEX_MATCHER_HPP
|
||||
#define BOOST_MULTI_INDEX_DETAIL_INDEX_MATCHER_HPP
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
|
||||
#include <algorithm>
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/multi_index/detail/auto_space.hpp>
|
||||
#include <boost/multi_index/detail/raw_ptr.hpp>
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
|
||||
namespace boost{
|
||||
|
||||
namespace multi_index{
|
||||
|
||||
namespace detail{
|
||||
|
||||
/* index_matcher compares a sequence of elements against a
|
||||
* base sequence, identifying those elements that belong to the
|
||||
* longest subsequence which is ordered with respect to the base.
|
||||
* For instance, if the base sequence is:
|
||||
*
|
||||
* 0 1 2 3 4 5 6 7 8 9
|
||||
*
|
||||
* and the compared sequence (not necesarilly the same length):
|
||||
*
|
||||
* 1 4 2 3 0 7 8 9
|
||||
*
|
||||
* the elements of the longest ordered subsequence are:
|
||||
*
|
||||
* 1 2 3 7 8 9
|
||||
*
|
||||
* The algorithm for obtaining such a subsequence is called
|
||||
* Patience Sorting, described in ch. 1 of:
|
||||
* Aldous, D., Diaconis, P.: "Longest increasing subsequences: from
|
||||
* patience sorting to the Baik-Deift-Johansson Theorem", Bulletin
|
||||
* of the American Mathematical Society, vol. 36, no 4, pp. 413-432,
|
||||
* July 1999.
|
||||
* http://www.ams.org/bull/1999-36-04/S0273-0979-99-00796-X/
|
||||
* S0273-0979-99-00796-X.pdf
|
||||
*
|
||||
* This implementation is not fully generic since it assumes that
|
||||
* the sequences given are pointed to by index iterators (having a
|
||||
* get_node() memfun.)
|
||||
*/
|
||||
|
||||
namespace index_matcher{
|
||||
|
||||
/* The algorithm stores the nodes of the base sequence and a number
|
||||
* of "piles" that are dynamically updated during the calculation
|
||||
* stage. From a logical point of view, nodes form an independent
|
||||
* sequence from piles. They are stored together so as to minimize
|
||||
* allocated memory.
|
||||
*/
|
||||
|
||||
struct entry
|
||||
{
|
||||
entry(void* node_,std::size_t pos_=0):node(node_),pos(pos_){}
|
||||
|
||||
/* node stuff */
|
||||
|
||||
void* node;
|
||||
std::size_t pos;
|
||||
entry* previous;
|
||||
bool ordered;
|
||||
|
||||
struct less_by_node
|
||||
{
|
||||
bool operator()(
|
||||
const entry& x,const entry& y)const
|
||||
{
|
||||
return std::less<void*>()(x.node,y.node);
|
||||
}
|
||||
};
|
||||
|
||||
/* pile stuff */
|
||||
|
||||
std::size_t pile_top;
|
||||
entry* pile_top_entry;
|
||||
|
||||
struct less_by_pile_top
|
||||
{
|
||||
bool operator()(
|
||||
const entry& x,const entry& y)const
|
||||
{
|
||||
return x.pile_top<y.pile_top;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
/* common code operating on void *'s */
|
||||
|
||||
template<typename Allocator>
|
||||
class algorithm_base:private noncopyable
|
||||
{
|
||||
protected:
|
||||
algorithm_base(const Allocator& al,std::size_t size):
|
||||
spc(al,size),size_(size),n_(0),sorted(false)
|
||||
{
|
||||
}
|
||||
|
||||
void add(void* node)
|
||||
{
|
||||
entries()[n_]=entry(node,n_);
|
||||
++n_;
|
||||
}
|
||||
|
||||
void begin_algorithm()const
|
||||
{
|
||||
if(!sorted){
|
||||
std::sort(entries(),entries()+size_,entry::less_by_node());
|
||||
sorted=true;
|
||||
}
|
||||
num_piles=0;
|
||||
}
|
||||
|
||||
void add_node_to_algorithm(void* node)const
|
||||
{
|
||||
entry* ent=
|
||||
std::lower_bound(
|
||||
entries(),entries()+size_,
|
||||
entry(node),entry::less_by_node()); /* localize entry */
|
||||
ent->ordered=false;
|
||||
std::size_t n=ent->pos; /* get its position */
|
||||
|
||||
entry dummy(0);
|
||||
dummy.pile_top=n;
|
||||
|
||||
entry* pile_ent= /* find the first available pile */
|
||||
std::lower_bound( /* to stack the entry */
|
||||
entries(),entries()+num_piles,
|
||||
dummy,entry::less_by_pile_top());
|
||||
|
||||
pile_ent->pile_top=n; /* stack the entry */
|
||||
pile_ent->pile_top_entry=ent;
|
||||
|
||||
/* if not the first pile, link entry to top of the preceding pile */
|
||||
if(pile_ent>&entries()[0]){
|
||||
ent->previous=(pile_ent-1)->pile_top_entry;
|
||||
}
|
||||
|
||||
if(pile_ent==&entries()[num_piles]){ /* new pile? */
|
||||
++num_piles;
|
||||
}
|
||||
}
|
||||
|
||||
void finish_algorithm()const
|
||||
{
|
||||
if(num_piles>0){
|
||||
/* Mark those elements which are in their correct position, i.e. those
|
||||
* belonging to the longest increasing subsequence. These are those
|
||||
* elements linked from the top of the last pile.
|
||||
*/
|
||||
|
||||
entry* ent=entries()[num_piles-1].pile_top_entry;
|
||||
for(std::size_t n=num_piles;n--;){
|
||||
ent->ordered=true;
|
||||
ent=ent->previous;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool is_ordered(void * node)const
|
||||
{
|
||||
return std::lower_bound(
|
||||
entries(),entries()+size_,
|
||||
entry(node),entry::less_by_node())->ordered;
|
||||
}
|
||||
|
||||
private:
|
||||
entry* entries()const{return raw_ptr<entry*>(spc.data());}
|
||||
|
||||
auto_space<entry,Allocator> spc;
|
||||
std::size_t size_;
|
||||
std::size_t n_;
|
||||
mutable bool sorted;
|
||||
mutable std::size_t num_piles;
|
||||
};
|
||||
|
||||
/* The algorithm has three phases:
|
||||
* - Initialization, during which the nodes of the base sequence are added.
|
||||
* - Execution.
|
||||
* - Results querying, through the is_ordered memfun.
|
||||
*/
|
||||
|
||||
template<typename Node,typename Allocator>
|
||||
class algorithm:private algorithm_base<Allocator>
|
||||
{
|
||||
typedef algorithm_base<Allocator> super;
|
||||
|
||||
public:
|
||||
algorithm(const Allocator& al,std::size_t size):super(al,size){}
|
||||
|
||||
void add(Node* node)
|
||||
{
|
||||
super::add(node);
|
||||
}
|
||||
|
||||
template<typename IndexIterator>
|
||||
void execute(IndexIterator first,IndexIterator last)const
|
||||
{
|
||||
super::begin_algorithm();
|
||||
|
||||
for(IndexIterator it=first;it!=last;++it){
|
||||
add_node_to_algorithm(get_node(it));
|
||||
}
|
||||
|
||||
super::finish_algorithm();
|
||||
}
|
||||
|
||||
bool is_ordered(Node* node)const
|
||||
{
|
||||
return super::is_ordered(node);
|
||||
}
|
||||
|
||||
private:
|
||||
void add_node_to_algorithm(Node* node)const
|
||||
{
|
||||
super::add_node_to_algorithm(node);
|
||||
}
|
||||
|
||||
template<typename IndexIterator>
|
||||
static Node* get_node(IndexIterator it)
|
||||
{
|
||||
return static_cast<Node*>(it.get_node());
|
||||
}
|
||||
};
|
||||
|
||||
} /* namespace multi_index::detail::index_matcher */
|
||||
|
||||
} /* namespace multi_index::detail */
|
||||
|
||||
} /* namespace multi_index */
|
||||
|
||||
} /* namespace boost */
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
|
||||
#ifndef BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED
|
||||
#define BOOST_MPL_AUX_FOLD_IMPL_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$
|
||||
|
||||
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
|
||||
# include <boost/mpl/next_prior.hpp>
|
||||
# include <boost/mpl/apply.hpp>
|
||||
# include <boost/mpl/deref.hpp>
|
||||
# include <boost/mpl/aux_/config/ctps.hpp>
|
||||
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
# include <boost/mpl/if.hpp>
|
||||
# include <boost/type_traits/is_same.hpp>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <boost/mpl/aux_/config/use_preprocessed.hpp>
|
||||
|
||||
#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
|
||||
&& !defined(BOOST_MPL_PREPROCESSING_MODE)
|
||||
|
||||
# define BOOST_MPL_PREPROCESSED_HEADER fold_impl.hpp
|
||||
# include <boost/mpl/aux_/include_preprocessed.hpp>
|
||||
|
||||
#else
|
||||
|
||||
# define AUX778076_FOLD_IMPL_OP(iter) typename deref<iter>::type
|
||||
# define AUX778076_FOLD_IMPL_NAME_PREFIX fold
|
||||
# include <boost/mpl/aux_/fold_impl_body.hpp>
|
||||
|
||||
#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
|
||||
#endif // BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED
|
||||
@@ -0,0 +1,197 @@
|
||||
#include "decodedtext.h"
|
||||
|
||||
#include <QStringList>
|
||||
#include <QRegularExpression>
|
||||
|
||||
extern "C" {
|
||||
bool stdmsg_(const char* msg, int len);
|
||||
}
|
||||
|
||||
DecodedText::DecodedText (QString const& the_string)
|
||||
: string_ {the_string}
|
||||
, padding_ {the_string.indexOf (" ") > 4 ? 2 : 0} // allow for
|
||||
// seconds
|
||||
, message_ {string_.mid (column_qsoText + padding_).trimmed ()}
|
||||
, is_standard_ {false}
|
||||
{
|
||||
if (message_.length() >= 1)
|
||||
{
|
||||
message_ = message_.left (22).remove (QRegularExpression {"[<>]"});
|
||||
int i1 = message_.indexOf ('\r');
|
||||
if (i1 > 0)
|
||||
{
|
||||
message_ = message_.left (i1 - 1);
|
||||
}
|
||||
// stdmsg is a fortran routine that packs the text, unpacks it and compares the result
|
||||
is_standard_ = stdmsg_ ((message_ + " ").toLatin1 ().constData (),22);
|
||||
}
|
||||
};
|
||||
|
||||
void DecodedText::removeAddedInfo ()
|
||||
{
|
||||
if (string_.indexOf (" CQ ") > 0) {
|
||||
// TODO this magic 37 characters is also referenced in DisplayText::_appendDXCCWorkedB4()
|
||||
auto eom_pos = string_.indexOf (' ', 37);
|
||||
if (eom_pos < 37) eom_pos = string_.size () - 1; // we always want at least the characters
|
||||
// to position 37
|
||||
string_ = string_.left (eom_pos + 1); // remove DXCC entity and worked B4 status. TODO need a better way to do this
|
||||
}
|
||||
}
|
||||
|
||||
QString DecodedText::CQersCall() const
|
||||
{
|
||||
QRegularExpression callsign_re {R"(^(CQ|DE|QRZ)(\s?DX|\s([A-Z]{2}|\d{3}))?\s(?<callsign>[A-Z0-9/]{2,})(\s[A-R]{2}[0-9]{2})?)"};
|
||||
return callsign_re.match (message_).captured ("callsign");
|
||||
}
|
||||
|
||||
|
||||
bool DecodedText::isJT65() const
|
||||
{
|
||||
return string_.indexOf("#") == column_mode + padding_;
|
||||
}
|
||||
|
||||
bool DecodedText::isJT9() const
|
||||
{
|
||||
return string_.indexOf("@") == column_mode + padding_;
|
||||
}
|
||||
|
||||
bool DecodedText::isTX() const
|
||||
{
|
||||
int i = string_.indexOf("Tx");
|
||||
return (i >= 0 && i < 15); // TODO guessing those numbers. Does Tx ever move?
|
||||
}
|
||||
|
||||
bool DecodedText::isLowConfidence () const
|
||||
{
|
||||
return QChar {'?'} == string_.mid (padding_ + column_qsoText + 21, 1);
|
||||
}
|
||||
|
||||
int DecodedText::frequencyOffset() const
|
||||
{
|
||||
return string_.mid(column_freq + padding_,4).toInt();
|
||||
}
|
||||
|
||||
int DecodedText::snr() const
|
||||
{
|
||||
int i1=string_.indexOf(" ")+1;
|
||||
return string_.mid(i1,3).toInt();
|
||||
}
|
||||
|
||||
float DecodedText::dt() const
|
||||
{
|
||||
return string_.mid(column_dt + padding_,5).toFloat();
|
||||
}
|
||||
|
||||
/*
|
||||
2343 -11 0.8 1259 # YV6BFE F6GUU R-08
|
||||
2343 -19 0.3 718 # VE6WQ SQ2NIJ -14
|
||||
2343 -7 0.3 815 # KK4DSD W7VP -16
|
||||
2343 -13 0.1 3627 @ CT1FBK IK5YZT R+02
|
||||
|
||||
0605 Tx 1259 # CQ VK3ACF QF22
|
||||
*/
|
||||
|
||||
// find and extract any report. Returns true if this is a standard message
|
||||
bool DecodedText::report(QString const& myBaseCall, QString const& dxBaseCall, /*mod*/QString& report) const
|
||||
{
|
||||
if (message_.size () < 1) return false;
|
||||
|
||||
QStringList const& w = message_.split(" ",QString::SkipEmptyParts);
|
||||
if (w.size ()
|
||||
&& is_standard_ && (w[0] == myBaseCall
|
||||
|| w[0].endsWith ("/" + myBaseCall)
|
||||
|| w[0].startsWith (myBaseCall + "/")
|
||||
|| (w.size () > 1 && !dxBaseCall.isEmpty ()
|
||||
&& (w[1] == dxBaseCall
|
||||
|| w[1].endsWith ("/" + dxBaseCall)
|
||||
|| w[1].startsWith (dxBaseCall + "/")))))
|
||||
{
|
||||
QString tt="";
|
||||
if(w.size() > 2) tt=w[2];
|
||||
bool ok;
|
||||
auto i1=tt.toInt(&ok);
|
||||
if (ok and i1>=-50 and i1<50)
|
||||
{
|
||||
report = tt;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (tt.mid(0,1)=="R")
|
||||
{
|
||||
i1=tt.mid(1).toInt(&ok);
|
||||
if(ok and i1>=-50 and i1<50)
|
||||
{
|
||||
report = tt.mid(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return is_standard_;
|
||||
}
|
||||
|
||||
// get the first text word, usually the call
|
||||
QString DecodedText::call() const
|
||||
{
|
||||
auto call = string_;
|
||||
call = call.replace (QRegularExpression {" CQ ([A-Z]{2,2}|[0-9]{3,3}) "}, " CQ_\\1 ").mid (column_qsoText + padding_);
|
||||
int i = call.indexOf(" ");
|
||||
return call.mid(0,i);
|
||||
}
|
||||
|
||||
// get the second word, most likely the de call and the third word, most likely grid
|
||||
void DecodedText::deCallAndGrid(/*out*/QString& call, QString& grid) const
|
||||
{
|
||||
auto msg = string_;
|
||||
if(msg.mid(4,1)!=" ") msg=msg.mid(0,4)+msg.mid(6,-1); //Remove seconds from UTC
|
||||
msg = msg.replace (QRegularExpression {" CQ ([A-Z]{2,2}|[0-9]{3,3}) "}, " CQ_\\1 ").mid (column_qsoText + padding_);
|
||||
int i1 = msg.indexOf (" ");
|
||||
call = msg.mid (i1 + 1);
|
||||
int i2 = call.indexOf (" ");
|
||||
if (" R " == call.mid (i2, 3)) // MSK144 contest mode report
|
||||
{
|
||||
grid = call.mid (i2 + 3, 4);
|
||||
}
|
||||
else
|
||||
{
|
||||
grid = call.mid (i2 + 1, 4);
|
||||
}
|
||||
call = call.left (i2).replace (">", "");
|
||||
}
|
||||
|
||||
int DecodedText::timeInSeconds() const
|
||||
{
|
||||
return 60*string_.mid(column_time,2).toInt() + string_.mid(2,2).toInt();
|
||||
}
|
||||
|
||||
/*
|
||||
2343 -11 0.8 1259 # YV6BFE F6GUU R-08
|
||||
2343 -19 0.3 718 # VE6WQ SQ2NIJ -14
|
||||
2343 -7 0.3 815 # KK4DSD W7VP -16
|
||||
2343 -13 0.1 3627 @ CT1FBK IK5YZT R+02
|
||||
|
||||
0605 Tx 1259 # CQ VK3ACF QF22
|
||||
*/
|
||||
|
||||
QString DecodedText::report() const // returns a string of the SNR field with a leading + or - followed by two digits
|
||||
{
|
||||
int sr = snr();
|
||||
if (sr<-50)
|
||||
sr = -50;
|
||||
else
|
||||
if (sr > 49)
|
||||
sr = 49;
|
||||
|
||||
QString rpt;
|
||||
rpt.sprintf("%d",abs(sr));
|
||||
if (sr > 9)
|
||||
rpt = "+" + rpt;
|
||||
else
|
||||
if (sr >= 0)
|
||||
rpt = "+0" + rpt;
|
||||
else
|
||||
if (sr >= -9)
|
||||
rpt = "-0" + rpt;
|
||||
else
|
||||
rpt = "-" + rpt;
|
||||
return rpt;
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0
|
||||
// See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
//
|
||||
// See http://boostorg.github.com/compute for more information.
|
||||
//---------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_COMPUTE_ALGORITHM_PARTITION_HPP
|
||||
#define BOOST_COMPUTE_ALGORITHM_PARTITION_HPP
|
||||
|
||||
#include <boost/compute/system.hpp>
|
||||
#include <boost/compute/command_queue.hpp>
|
||||
#include <boost/compute/algorithm/stable_partition.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace compute {
|
||||
|
||||
///
|
||||
/// Partitions the elements in the range [\p first, \p last) according to
|
||||
/// \p predicate. Order of the elements need not be preserved.
|
||||
///
|
||||
/// \see is_partitioned() and stable_partition()
|
||||
///
|
||||
template<class Iterator, class UnaryPredicate>
|
||||
inline Iterator partition(Iterator first,
|
||||
Iterator last,
|
||||
UnaryPredicate predicate,
|
||||
command_queue &queue = system::default_queue())
|
||||
{
|
||||
return stable_partition(first, last, predicate, queue);
|
||||
}
|
||||
|
||||
} // end compute namespace
|
||||
} // end boost namespace
|
||||
|
||||
#endif // BOOST_COMPUTE_ALGORITHM_PARTITION_HPP
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,122 @@
|
||||
/* boost random/detail/large_arithmetic.hpp header file
|
||||
*
|
||||
* Copyright Steven Watanabe 2011
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
* See http://www.boost.org for most recent version including documentation.
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#ifndef BOOST_RANDOM_DETAIL_LARGE_ARITHMETIC_HPP
|
||||
#define BOOST_RANDOM_DETAIL_LARGE_ARITHMETIC_HPP
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/integer.hpp>
|
||||
#include <boost/limits.hpp>
|
||||
#include <boost/random/detail/integer_log2.hpp>
|
||||
|
||||
#include <boost/random/detail/disable_warnings.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace random {
|
||||
namespace detail {
|
||||
|
||||
struct div_t {
|
||||
boost::uintmax_t quotient;
|
||||
boost::uintmax_t remainder;
|
||||
};
|
||||
|
||||
inline div_t muldivmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
|
||||
{
|
||||
const int bits =
|
||||
::std::numeric_limits< ::boost::uintmax_t>::digits / 2;
|
||||
const ::boost::uintmax_t mask = (::boost::uintmax_t(1) << bits) - 1;
|
||||
typedef ::boost::uint_t<bits>::fast digit_t;
|
||||
|
||||
int shift = std::numeric_limits< ::boost::uintmax_t>::digits - 1
|
||||
- detail::integer_log2(m);
|
||||
|
||||
a <<= shift;
|
||||
m <<= shift;
|
||||
|
||||
digit_t product[4] = { 0, 0, 0, 0 };
|
||||
digit_t a_[2] = { digit_t(a & mask), digit_t((a >> bits) & mask) };
|
||||
digit_t b_[2] = { digit_t(b & mask), digit_t((b >> bits) & mask) };
|
||||
digit_t m_[2] = { digit_t(m & mask), digit_t((m >> bits) & mask) };
|
||||
|
||||
// multiply a * b
|
||||
for(int i = 0; i < 2; ++i) {
|
||||
digit_t carry = 0;
|
||||
for(int j = 0; j < 2; ++j) {
|
||||
::boost::uint64_t temp = ::boost::uintmax_t(a_[i]) * b_[j] +
|
||||
carry + product[i + j];
|
||||
product[i + j] = digit_t(temp & mask);
|
||||
carry = digit_t(temp >> bits);
|
||||
}
|
||||
if(carry != 0) {
|
||||
product[i + 2] += carry;
|
||||
}
|
||||
}
|
||||
|
||||
digit_t quotient[2];
|
||||
|
||||
if(m == 0) {
|
||||
div_t result = {
|
||||
((::boost::uintmax_t(product[3]) << bits) | product[2]),
|
||||
((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
// divide product / m
|
||||
for(int i = 3; i >= 2; --i) {
|
||||
::boost::uintmax_t temp =
|
||||
::boost::uintmax_t(product[i]) << bits | product[i - 1];
|
||||
|
||||
digit_t q = digit_t((product[i] == m_[1]) ? mask : temp / m_[1]);
|
||||
|
||||
::boost::uintmax_t rem =
|
||||
((temp - ::boost::uintmax_t(q) * m_[1]) << bits) + product[i - 2];
|
||||
|
||||
::boost::uintmax_t diff = m_[0] * ::boost::uintmax_t(q);
|
||||
|
||||
int error = 0;
|
||||
if(diff > rem) {
|
||||
if(diff - rem > m) {
|
||||
error = 2;
|
||||
} else {
|
||||
error = 1;
|
||||
}
|
||||
}
|
||||
q -= error;
|
||||
rem = rem + error * m - diff;
|
||||
|
||||
quotient[i - 2] = q;
|
||||
product[i] = 0;
|
||||
product[i-1] = static_cast<digit_t>((rem >> bits) & mask);
|
||||
product[i-2] = static_cast<digit_t>(rem & mask);
|
||||
}
|
||||
|
||||
div_t result = {
|
||||
((::boost::uintmax_t(quotient[1]) << bits) | quotient[0]),
|
||||
((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
inline boost::uintmax_t muldiv(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
|
||||
{ return detail::muldivmod(a, b, m).quotient; }
|
||||
|
||||
inline boost::uintmax_t mulmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
|
||||
{ return detail::muldivmod(a, b, m).remainder; }
|
||||
|
||||
} // namespace detail
|
||||
} // namespace random
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/random/detail/enable_warnings.hpp>
|
||||
|
||||
#endif // BOOST_RANDOM_DETAIL_LARGE_ARITHMETIC_HPP
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,788 @@
|
||||
// Copyright John Maddock 2006.
|
||||
// Use, modification and distribution are subject to the
|
||||
// Boost Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_MATH_SP_UC_FACTORIALS_HPP
|
||||
#define BOOST_MATH_SP_UC_FACTORIALS_HPP
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push) // Temporary until lexical cast fixed.
|
||||
#pragma warning(disable: 4127 4701)
|
||||
#endif
|
||||
#ifndef BOOST_MATH_NO_LEXICAL_CAST
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#endif
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
#include <boost/config/no_tr1/cmath.hpp>
|
||||
#include <boost/math/special_functions/math_fwd.hpp>
|
||||
|
||||
namespace boost { namespace math
|
||||
{
|
||||
// Forward declarations:
|
||||
template <class T>
|
||||
struct max_factorial;
|
||||
|
||||
// Definitions:
|
||||
template <>
|
||||
inline float unchecked_factorial<float>(unsigned i BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(float))
|
||||
{
|
||||
static const boost::array<float, 35> factorials = {{
|
||||
1.0F,
|
||||
1.0F,
|
||||
2.0F,
|
||||
6.0F,
|
||||
24.0F,
|
||||
120.0F,
|
||||
720.0F,
|
||||
5040.0F,
|
||||
40320.0F,
|
||||
362880.0F,
|
||||
3628800.0F,
|
||||
39916800.0F,
|
||||
479001600.0F,
|
||||
6227020800.0F,
|
||||
87178291200.0F,
|
||||
1307674368000.0F,
|
||||
20922789888000.0F,
|
||||
355687428096000.0F,
|
||||
6402373705728000.0F,
|
||||
121645100408832000.0F,
|
||||
0.243290200817664e19F,
|
||||
0.5109094217170944e20F,
|
||||
0.112400072777760768e22F,
|
||||
0.2585201673888497664e23F,
|
||||
0.62044840173323943936e24F,
|
||||
0.15511210043330985984e26F,
|
||||
0.403291461126605635584e27F,
|
||||
0.10888869450418352160768e29F,
|
||||
0.304888344611713860501504e30F,
|
||||
0.8841761993739701954543616e31F,
|
||||
0.26525285981219105863630848e33F,
|
||||
0.822283865417792281772556288e34F,
|
||||
0.26313083693369353016721801216e36F,
|
||||
0.868331761881188649551819440128e37F,
|
||||
0.29523279903960414084761860964352e39F,
|
||||
}};
|
||||
|
||||
return factorials[i];
|
||||
}
|
||||
|
||||
template <>
|
||||
struct max_factorial<float>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(unsigned, value = 34);
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
inline long double unchecked_factorial<long double>(unsigned i BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(long double))
|
||||
{
|
||||
static const boost::array<long double, 171> factorials = {{
|
||||
1L,
|
||||
1L,
|
||||
2L,
|
||||
6L,
|
||||
24L,
|
||||
120L,
|
||||
720L,
|
||||
5040L,
|
||||
40320L,
|
||||
362880.0L,
|
||||
3628800.0L,
|
||||
39916800.0L,
|
||||
479001600.0L,
|
||||
6227020800.0L,
|
||||
87178291200.0L,
|
||||
1307674368000.0L,
|
||||
20922789888000.0L,
|
||||
355687428096000.0L,
|
||||
6402373705728000.0L,
|
||||
121645100408832000.0L,
|
||||
0.243290200817664e19L,
|
||||
0.5109094217170944e20L,
|
||||
0.112400072777760768e22L,
|
||||
0.2585201673888497664e23L,
|
||||
0.62044840173323943936e24L,
|
||||
0.15511210043330985984e26L,
|
||||
0.403291461126605635584e27L,
|
||||
0.10888869450418352160768e29L,
|
||||
0.304888344611713860501504e30L,
|
||||
0.8841761993739701954543616e31L,
|
||||
0.26525285981219105863630848e33L,
|
||||
0.822283865417792281772556288e34L,
|
||||
0.26313083693369353016721801216e36L,
|
||||
0.868331761881188649551819440128e37L,
|
||||
0.29523279903960414084761860964352e39L,
|
||||
0.103331479663861449296666513375232e41L,
|
||||
0.3719933267899012174679994481508352e42L,
|
||||
0.137637530912263450463159795815809024e44L,
|
||||
0.5230226174666011117600072241000742912e45L,
|
||||
0.203978820811974433586402817399028973568e47L,
|
||||
0.815915283247897734345611269596115894272e48L,
|
||||
0.3345252661316380710817006205344075166515e50L,
|
||||
0.1405006117752879898543142606244511569936e52L,
|
||||
0.6041526306337383563735513206851399750726e53L,
|
||||
0.265827157478844876804362581101461589032e55L,
|
||||
0.1196222208654801945619631614956577150644e57L,
|
||||
0.5502622159812088949850305428800254892962e58L,
|
||||
0.2586232415111681806429643551536119799692e60L,
|
||||
0.1241391559253607267086228904737337503852e62L,
|
||||
0.6082818640342675608722521633212953768876e63L,
|
||||
0.3041409320171337804361260816606476884438e65L,
|
||||
0.1551118753287382280224243016469303211063e67L,
|
||||
0.8065817517094387857166063685640376697529e68L,
|
||||
0.427488328406002556429801375338939964969e70L,
|
||||
0.2308436973392413804720927426830275810833e72L,
|
||||
0.1269640335365827592596510084756651695958e74L,
|
||||
0.7109985878048634518540456474637249497365e75L,
|
||||
0.4052691950487721675568060190543232213498e77L,
|
||||
0.2350561331282878571829474910515074683829e79L,
|
||||
0.1386831185456898357379390197203894063459e81L,
|
||||
0.8320987112741390144276341183223364380754e82L,
|
||||
0.507580213877224798800856812176625227226e84L,
|
||||
0.3146997326038793752565312235495076408801e86L,
|
||||
0.1982608315404440064116146708361898137545e88L,
|
||||
0.1268869321858841641034333893351614808029e90L,
|
||||
0.8247650592082470666723170306785496252186e91L,
|
||||
0.5443449390774430640037292402478427526443e93L,
|
||||
0.3647111091818868528824985909660546442717e95L,
|
||||
0.2480035542436830599600990418569171581047e97L,
|
||||
0.1711224524281413113724683388812728390923e99L,
|
||||
0.1197857166996989179607278372168909873646e101L,
|
||||
0.8504785885678623175211676442399260102886e102L,
|
||||
0.6123445837688608686152407038527467274078e104L,
|
||||
0.4470115461512684340891257138125051110077e106L,
|
||||
0.3307885441519386412259530282212537821457e108L,
|
||||
0.2480914081139539809194647711659403366093e110L,
|
||||
0.188549470166605025498793226086114655823e112L,
|
||||
0.1451830920282858696340707840863082849837e114L,
|
||||
0.1132428117820629783145752115873204622873e116L,
|
||||
0.8946182130782975286851441715398316520698e117L,
|
||||
0.7156945704626380229481153372318653216558e119L,
|
||||
0.5797126020747367985879734231578109105412e121L,
|
||||
0.4753643337012841748421382069894049466438e123L,
|
||||
0.3945523969720658651189747118012061057144e125L,
|
||||
0.3314240134565353266999387579130131288001e127L,
|
||||
0.2817104114380550276949479442260611594801e129L,
|
||||
0.2422709538367273238176552320344125971528e131L,
|
||||
0.210775729837952771721360051869938959523e133L,
|
||||
0.1854826422573984391147968456455462843802e135L,
|
||||
0.1650795516090846108121691926245361930984e137L,
|
||||
0.1485715964481761497309522733620825737886e139L,
|
||||
0.1352001527678402962551665687594951421476e141L,
|
||||
0.1243841405464130725547532432587355307758e143L,
|
||||
0.1156772507081641574759205162306240436215e145L,
|
||||
0.1087366156656743080273652852567866010042e147L,
|
||||
0.103299784882390592625997020993947270954e149L,
|
||||
0.9916779348709496892095714015418938011582e150L,
|
||||
0.9619275968248211985332842594956369871234e152L,
|
||||
0.942689044888324774562618574305724247381e154L,
|
||||
0.9332621544394415268169923885626670049072e156L,
|
||||
0.9332621544394415268169923885626670049072e158L,
|
||||
0.9425947759838359420851623124482936749562e160L,
|
||||
0.9614466715035126609268655586972595484554e162L,
|
||||
0.990290071648618040754671525458177334909e164L,
|
||||
0.1029901674514562762384858386476504428305e167L,
|
||||
0.1081396758240290900504101305800329649721e169L,
|
||||
0.1146280563734708354534347384148349428704e171L,
|
||||
0.1226520203196137939351751701038733888713e173L,
|
||||
0.132464181945182897449989183712183259981e175L,
|
||||
0.1443859583202493582204882102462797533793e177L,
|
||||
0.1588245541522742940425370312709077287172e179L,
|
||||
0.1762952551090244663872161047107075788761e181L,
|
||||
0.1974506857221074023536820372759924883413e183L,
|
||||
0.2231192748659813646596607021218715118256e185L,
|
||||
0.2543559733472187557120132004189335234812e187L,
|
||||
0.2925093693493015690688151804817735520034e189L,
|
||||
0.339310868445189820119825609358857320324e191L,
|
||||
0.396993716080872089540195962949863064779e193L,
|
||||
0.4684525849754290656574312362808384164393e195L,
|
||||
0.5574585761207605881323431711741977155627e197L,
|
||||
0.6689502913449127057588118054090372586753e199L,
|
||||
0.8094298525273443739681622845449350829971e201L,
|
||||
0.9875044200833601362411579871448208012564e203L,
|
||||
0.1214630436702532967576624324188129585545e206L,
|
||||
0.1506141741511140879795014161993280686076e208L,
|
||||
0.1882677176888926099743767702491600857595e210L,
|
||||
0.237217324288004688567714730513941708057e212L,
|
||||
0.3012660018457659544809977077527059692324e214L,
|
||||
0.3856204823625804217356770659234636406175e216L,
|
||||
0.4974504222477287440390234150412680963966e218L,
|
||||
0.6466855489220473672507304395536485253155e220L,
|
||||
0.8471580690878820510984568758152795681634e222L,
|
||||
0.1118248651196004307449963076076169029976e225L,
|
||||
0.1487270706090685728908450891181304809868e227L,
|
||||
0.1992942746161518876737324194182948445223e229L,
|
||||
0.269047270731805048359538766214698040105e231L,
|
||||
0.3659042881952548657689727220519893345429e233L,
|
||||
0.5012888748274991661034926292112253883237e235L,
|
||||
0.6917786472619488492228198283114910358867e237L,
|
||||
0.9615723196941089004197195613529725398826e239L,
|
||||
0.1346201247571752460587607385894161555836e242L,
|
||||
0.1898143759076170969428526414110767793728e244L,
|
||||
0.2695364137888162776588507508037290267094e246L,
|
||||
0.3854370717180072770521565736493325081944e248L,
|
||||
0.5550293832739304789551054660550388118e250L,
|
||||
0.80479260574719919448490292577980627711e252L,
|
||||
0.1174997204390910823947958271638517164581e255L,
|
||||
0.1727245890454638911203498659308620231933e257L,
|
||||
0.2556323917872865588581178015776757943262e259L,
|
||||
0.380892263763056972698595524350736933546e261L,
|
||||
0.571338395644585459047893286526105400319e263L,
|
||||
0.8627209774233240431623188626544191544816e265L,
|
||||
0.1311335885683452545606724671234717114812e268L,
|
||||
0.2006343905095682394778288746989117185662e270L,
|
||||
0.308976961384735088795856467036324046592e272L,
|
||||
0.4789142901463393876335775239063022722176e274L,
|
||||
0.7471062926282894447083809372938315446595e276L,
|
||||
0.1172956879426414428192158071551315525115e279L,
|
||||
0.1853271869493734796543609753051078529682e281L,
|
||||
0.2946702272495038326504339507351214862195e283L,
|
||||
0.4714723635992061322406943211761943779512e285L,
|
||||
0.7590705053947218729075178570936729485014e287L,
|
||||
0.1229694218739449434110178928491750176572e290L,
|
||||
0.2004401576545302577599591653441552787813e292L,
|
||||
0.3287218585534296227263330311644146572013e294L,
|
||||
0.5423910666131588774984495014212841843822e296L,
|
||||
0.9003691705778437366474261723593317460744e298L,
|
||||
0.1503616514864999040201201707840084015944e301L,
|
||||
0.2526075744973198387538018869171341146786e303L,
|
||||
0.4269068009004705274939251888899566538069e305L,
|
||||
0.7257415615307998967396728211129263114717e307L,
|
||||
}};
|
||||
|
||||
return factorials[i];
|
||||
}
|
||||
|
||||
template <>
|
||||
struct max_factorial<long double>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(unsigned, value = 170);
|
||||
};
|
||||
|
||||
#ifdef BOOST_MATH_USE_FLOAT128
|
||||
|
||||
template <>
|
||||
inline BOOST_MATH_FLOAT128_TYPE unchecked_factorial<BOOST_MATH_FLOAT128_TYPE>(unsigned i)
|
||||
{
|
||||
static const boost::array<BOOST_MATH_FLOAT128_TYPE, 171> factorials = { {
|
||||
1,
|
||||
1,
|
||||
2,
|
||||
6,
|
||||
24,
|
||||
120,
|
||||
720,
|
||||
5040,
|
||||
40320,
|
||||
362880.0Q,
|
||||
3628800.0Q,
|
||||
39916800.0Q,
|
||||
479001600.0Q,
|
||||
6227020800.0Q,
|
||||
87178291200.0Q,
|
||||
1307674368000.0Q,
|
||||
20922789888000.0Q,
|
||||
355687428096000.0Q,
|
||||
6402373705728000.0Q,
|
||||
121645100408832000.0Q,
|
||||
0.243290200817664e19Q,
|
||||
0.5109094217170944e20Q,
|
||||
0.112400072777760768e22Q,
|
||||
0.2585201673888497664e23Q,
|
||||
0.62044840173323943936e24Q,
|
||||
0.15511210043330985984e26Q,
|
||||
0.403291461126605635584e27Q,
|
||||
0.10888869450418352160768e29Q,
|
||||
0.304888344611713860501504e30Q,
|
||||
0.8841761993739701954543616e31Q,
|
||||
0.26525285981219105863630848e33Q,
|
||||
0.822283865417792281772556288e34Q,
|
||||
0.26313083693369353016721801216e36Q,
|
||||
0.868331761881188649551819440128e37Q,
|
||||
0.29523279903960414084761860964352e39Q,
|
||||
0.103331479663861449296666513375232e41Q,
|
||||
0.3719933267899012174679994481508352e42Q,
|
||||
0.137637530912263450463159795815809024e44Q,
|
||||
0.5230226174666011117600072241000742912e45Q,
|
||||
0.203978820811974433586402817399028973568e47Q,
|
||||
0.815915283247897734345611269596115894272e48Q,
|
||||
0.3345252661316380710817006205344075166515e50Q,
|
||||
0.1405006117752879898543142606244511569936e52Q,
|
||||
0.6041526306337383563735513206851399750726e53Q,
|
||||
0.265827157478844876804362581101461589032e55Q,
|
||||
0.1196222208654801945619631614956577150644e57Q,
|
||||
0.5502622159812088949850305428800254892962e58Q,
|
||||
0.2586232415111681806429643551536119799692e60Q,
|
||||
0.1241391559253607267086228904737337503852e62Q,
|
||||
0.6082818640342675608722521633212953768876e63Q,
|
||||
0.3041409320171337804361260816606476884438e65Q,
|
||||
0.1551118753287382280224243016469303211063e67Q,
|
||||
0.8065817517094387857166063685640376697529e68Q,
|
||||
0.427488328406002556429801375338939964969e70Q,
|
||||
0.2308436973392413804720927426830275810833e72Q,
|
||||
0.1269640335365827592596510084756651695958e74Q,
|
||||
0.7109985878048634518540456474637249497365e75Q,
|
||||
0.4052691950487721675568060190543232213498e77Q,
|
||||
0.2350561331282878571829474910515074683829e79Q,
|
||||
0.1386831185456898357379390197203894063459e81Q,
|
||||
0.8320987112741390144276341183223364380754e82Q,
|
||||
0.507580213877224798800856812176625227226e84Q,
|
||||
0.3146997326038793752565312235495076408801e86Q,
|
||||
0.1982608315404440064116146708361898137545e88Q,
|
||||
0.1268869321858841641034333893351614808029e90Q,
|
||||
0.8247650592082470666723170306785496252186e91Q,
|
||||
0.5443449390774430640037292402478427526443e93Q,
|
||||
0.3647111091818868528824985909660546442717e95Q,
|
||||
0.2480035542436830599600990418569171581047e97Q,
|
||||
0.1711224524281413113724683388812728390923e99Q,
|
||||
0.1197857166996989179607278372168909873646e101Q,
|
||||
0.8504785885678623175211676442399260102886e102Q,
|
||||
0.6123445837688608686152407038527467274078e104Q,
|
||||
0.4470115461512684340891257138125051110077e106Q,
|
||||
0.3307885441519386412259530282212537821457e108Q,
|
||||
0.2480914081139539809194647711659403366093e110Q,
|
||||
0.188549470166605025498793226086114655823e112Q,
|
||||
0.1451830920282858696340707840863082849837e114Q,
|
||||
0.1132428117820629783145752115873204622873e116Q,
|
||||
0.8946182130782975286851441715398316520698e117Q,
|
||||
0.7156945704626380229481153372318653216558e119Q,
|
||||
0.5797126020747367985879734231578109105412e121Q,
|
||||
0.4753643337012841748421382069894049466438e123Q,
|
||||
0.3945523969720658651189747118012061057144e125Q,
|
||||
0.3314240134565353266999387579130131288001e127Q,
|
||||
0.2817104114380550276949479442260611594801e129Q,
|
||||
0.2422709538367273238176552320344125971528e131Q,
|
||||
0.210775729837952771721360051869938959523e133Q,
|
||||
0.1854826422573984391147968456455462843802e135Q,
|
||||
0.1650795516090846108121691926245361930984e137Q,
|
||||
0.1485715964481761497309522733620825737886e139Q,
|
||||
0.1352001527678402962551665687594951421476e141Q,
|
||||
0.1243841405464130725547532432587355307758e143Q,
|
||||
0.1156772507081641574759205162306240436215e145Q,
|
||||
0.1087366156656743080273652852567866010042e147Q,
|
||||
0.103299784882390592625997020993947270954e149Q,
|
||||
0.9916779348709496892095714015418938011582e150Q,
|
||||
0.9619275968248211985332842594956369871234e152Q,
|
||||
0.942689044888324774562618574305724247381e154Q,
|
||||
0.9332621544394415268169923885626670049072e156Q,
|
||||
0.9332621544394415268169923885626670049072e158Q,
|
||||
0.9425947759838359420851623124482936749562e160Q,
|
||||
0.9614466715035126609268655586972595484554e162Q,
|
||||
0.990290071648618040754671525458177334909e164Q,
|
||||
0.1029901674514562762384858386476504428305e167Q,
|
||||
0.1081396758240290900504101305800329649721e169Q,
|
||||
0.1146280563734708354534347384148349428704e171Q,
|
||||
0.1226520203196137939351751701038733888713e173Q,
|
||||
0.132464181945182897449989183712183259981e175Q,
|
||||
0.1443859583202493582204882102462797533793e177Q,
|
||||
0.1588245541522742940425370312709077287172e179Q,
|
||||
0.1762952551090244663872161047107075788761e181Q,
|
||||
0.1974506857221074023536820372759924883413e183Q,
|
||||
0.2231192748659813646596607021218715118256e185Q,
|
||||
0.2543559733472187557120132004189335234812e187Q,
|
||||
0.2925093693493015690688151804817735520034e189Q,
|
||||
0.339310868445189820119825609358857320324e191Q,
|
||||
0.396993716080872089540195962949863064779e193Q,
|
||||
0.4684525849754290656574312362808384164393e195Q,
|
||||
0.5574585761207605881323431711741977155627e197Q,
|
||||
0.6689502913449127057588118054090372586753e199Q,
|
||||
0.8094298525273443739681622845449350829971e201Q,
|
||||
0.9875044200833601362411579871448208012564e203Q,
|
||||
0.1214630436702532967576624324188129585545e206Q,
|
||||
0.1506141741511140879795014161993280686076e208Q,
|
||||
0.1882677176888926099743767702491600857595e210Q,
|
||||
0.237217324288004688567714730513941708057e212Q,
|
||||
0.3012660018457659544809977077527059692324e214Q,
|
||||
0.3856204823625804217356770659234636406175e216Q,
|
||||
0.4974504222477287440390234150412680963966e218Q,
|
||||
0.6466855489220473672507304395536485253155e220Q,
|
||||
0.8471580690878820510984568758152795681634e222Q,
|
||||
0.1118248651196004307449963076076169029976e225Q,
|
||||
0.1487270706090685728908450891181304809868e227Q,
|
||||
0.1992942746161518876737324194182948445223e229Q,
|
||||
0.269047270731805048359538766214698040105e231Q,
|
||||
0.3659042881952548657689727220519893345429e233Q,
|
||||
0.5012888748274991661034926292112253883237e235Q,
|
||||
0.6917786472619488492228198283114910358867e237Q,
|
||||
0.9615723196941089004197195613529725398826e239Q,
|
||||
0.1346201247571752460587607385894161555836e242Q,
|
||||
0.1898143759076170969428526414110767793728e244Q,
|
||||
0.2695364137888162776588507508037290267094e246Q,
|
||||
0.3854370717180072770521565736493325081944e248Q,
|
||||
0.5550293832739304789551054660550388118e250Q,
|
||||
0.80479260574719919448490292577980627711e252Q,
|
||||
0.1174997204390910823947958271638517164581e255Q,
|
||||
0.1727245890454638911203498659308620231933e257Q,
|
||||
0.2556323917872865588581178015776757943262e259Q,
|
||||
0.380892263763056972698595524350736933546e261Q,
|
||||
0.571338395644585459047893286526105400319e263Q,
|
||||
0.8627209774233240431623188626544191544816e265Q,
|
||||
0.1311335885683452545606724671234717114812e268Q,
|
||||
0.2006343905095682394778288746989117185662e270Q,
|
||||
0.308976961384735088795856467036324046592e272Q,
|
||||
0.4789142901463393876335775239063022722176e274Q,
|
||||
0.7471062926282894447083809372938315446595e276Q,
|
||||
0.1172956879426414428192158071551315525115e279Q,
|
||||
0.1853271869493734796543609753051078529682e281Q,
|
||||
0.2946702272495038326504339507351214862195e283Q,
|
||||
0.4714723635992061322406943211761943779512e285Q,
|
||||
0.7590705053947218729075178570936729485014e287Q,
|
||||
0.1229694218739449434110178928491750176572e290Q,
|
||||
0.2004401576545302577599591653441552787813e292Q,
|
||||
0.3287218585534296227263330311644146572013e294Q,
|
||||
0.5423910666131588774984495014212841843822e296Q,
|
||||
0.9003691705778437366474261723593317460744e298Q,
|
||||
0.1503616514864999040201201707840084015944e301Q,
|
||||
0.2526075744973198387538018869171341146786e303Q,
|
||||
0.4269068009004705274939251888899566538069e305Q,
|
||||
0.7257415615307998967396728211129263114717e307Q,
|
||||
} };
|
||||
|
||||
return factorials[i];
|
||||
}
|
||||
|
||||
template <>
|
||||
struct max_factorial<BOOST_MATH_FLOAT128_TYPE>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(unsigned, value = 170);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
template <>
|
||||
inline double unchecked_factorial<double>(unsigned i BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(double))
|
||||
{
|
||||
return static_cast<double>(boost::math::unchecked_factorial<long double>(i));
|
||||
}
|
||||
|
||||
template <>
|
||||
struct max_factorial<double>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(unsigned,
|
||||
value = ::boost::math::max_factorial<long double>::value);
|
||||
};
|
||||
|
||||
#ifndef BOOST_MATH_NO_LEXICAL_CAST
|
||||
|
||||
template <class T>
|
||||
struct unchecked_factorial_initializer
|
||||
{
|
||||
struct init
|
||||
{
|
||||
init()
|
||||
{
|
||||
boost::math::unchecked_factorial<T>(3);
|
||||
}
|
||||
void force_instantiate()const {}
|
||||
};
|
||||
static const init initializer;
|
||||
static void force_instantiate()
|
||||
{
|
||||
initializer.force_instantiate();
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
const typename unchecked_factorial_initializer<T>::init unchecked_factorial_initializer<T>::initializer;
|
||||
|
||||
|
||||
template <class T, int N>
|
||||
inline T unchecked_factorial_imp(unsigned i, const mpl::int_<N>&)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(!boost::is_integral<T>::value);
|
||||
// factorial<unsigned int>(n) is not implemented
|
||||
// because it would overflow integral type T for too small n
|
||||
// to be useful. Use instead a floating-point type,
|
||||
// and convert to an unsigned type if essential, for example:
|
||||
// unsigned int nfac = static_cast<unsigned int>(factorial<double>(n));
|
||||
// See factorial documentation for more detail.
|
||||
|
||||
unchecked_factorial_initializer<T>::force_instantiate();
|
||||
|
||||
static const boost::array<T, 101> factorials = {{
|
||||
T(boost::math::tools::convert_from_string<T>("1")),
|
||||
T(boost::math::tools::convert_from_string<T>("1")),
|
||||
T(boost::math::tools::convert_from_string<T>("2")),
|
||||
T(boost::math::tools::convert_from_string<T>("6")),
|
||||
T(boost::math::tools::convert_from_string<T>("24")),
|
||||
T(boost::math::tools::convert_from_string<T>("120")),
|
||||
T(boost::math::tools::convert_from_string<T>("720")),
|
||||
T(boost::math::tools::convert_from_string<T>("5040")),
|
||||
T(boost::math::tools::convert_from_string<T>("40320")),
|
||||
T(boost::math::tools::convert_from_string<T>("362880")),
|
||||
T(boost::math::tools::convert_from_string<T>("3628800")),
|
||||
T(boost::math::tools::convert_from_string<T>("39916800")),
|
||||
T(boost::math::tools::convert_from_string<T>("479001600")),
|
||||
T(boost::math::tools::convert_from_string<T>("6227020800")),
|
||||
T(boost::math::tools::convert_from_string<T>("87178291200")),
|
||||
T(boost::math::tools::convert_from_string<T>("1307674368000")),
|
||||
T(boost::math::tools::convert_from_string<T>("20922789888000")),
|
||||
T(boost::math::tools::convert_from_string<T>("355687428096000")),
|
||||
T(boost::math::tools::convert_from_string<T>("6402373705728000")),
|
||||
T(boost::math::tools::convert_from_string<T>("121645100408832000")),
|
||||
T(boost::math::tools::convert_from_string<T>("2432902008176640000")),
|
||||
T(boost::math::tools::convert_from_string<T>("51090942171709440000")),
|
||||
T(boost::math::tools::convert_from_string<T>("1124000727777607680000")),
|
||||
T(boost::math::tools::convert_from_string<T>("25852016738884976640000")),
|
||||
T(boost::math::tools::convert_from_string<T>("620448401733239439360000")),
|
||||
T(boost::math::tools::convert_from_string<T>("15511210043330985984000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("403291461126605635584000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("10888869450418352160768000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("304888344611713860501504000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("8841761993739701954543616000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("265252859812191058636308480000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("8222838654177922817725562880000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("263130836933693530167218012160000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("8683317618811886495518194401280000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("295232799039604140847618609643520000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("10333147966386144929666651337523200000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("371993326789901217467999448150835200000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("13763753091226345046315979581580902400000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("523022617466601111760007224100074291200000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("20397882081197443358640281739902897356800000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("815915283247897734345611269596115894272000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("33452526613163807108170062053440751665152000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("1405006117752879898543142606244511569936384000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("60415263063373835637355132068513997507264512000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("2658271574788448768043625811014615890319638528000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("119622220865480194561963161495657715064383733760000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("5502622159812088949850305428800254892961651752960000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("258623241511168180642964355153611979969197632389120000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("12413915592536072670862289047373375038521486354677760000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("608281864034267560872252163321295376887552831379210240000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("30414093201713378043612608166064768844377641568960512000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("1551118753287382280224243016469303211063259720016986112000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("80658175170943878571660636856403766975289505440883277824000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("4274883284060025564298013753389399649690343788366813724672000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("230843697339241380472092742683027581083278564571807941132288000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("12696403353658275925965100847566516959580321051449436762275840000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("710998587804863451854045647463724949736497978881168458687447040000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("40526919504877216755680601905432322134980384796226602145184481280000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("2350561331282878571829474910515074683828862318181142924420699914240000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("138683118545689835737939019720389406345902876772687432540821294940160000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("8320987112741390144276341183223364380754172606361245952449277696409600000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("507580213877224798800856812176625227226004528988036003099405939480985600000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("31469973260387937525653122354950764088012280797258232192163168247821107200000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("1982608315404440064116146708361898137544773690227268628106279599612729753600000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("8247650592082470666723170306785496252186258551345437492922123134388955774976000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("544344939077443064003729240247842752644293064388798874532860126869671081148416000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("36471110918188685288249859096605464427167635314049524593701628500267962436943872000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("2480035542436830599600990418569171581047399201355367672371710738018221445712183296000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("171122452428141311372468338881272839092270544893520369393648040923257279754140647424000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("11978571669969891796072783721689098736458938142546425857555362864628009582789845319680000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("850478588567862317521167644239926010288584608120796235886430763388588680378079017697280000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("61234458376886086861524070385274672740778091784697328983823014963978384987221689274204160000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("4470115461512684340891257138125051110076800700282905015819080092370422104067183317016903680000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("330788544151938641225953028221253782145683251820934971170611926835411235700971565459250872320000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("24809140811395398091946477116594033660926243886570122837795894512655842677572867409443815424000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("1885494701666050254987932260861146558230394535379329335672487982961844043495537923117729972224000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("145183092028285869634070784086308284983740379224208358846781574688061991349156420080065207861248000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("11324281178206297831457521158732046228731749579488251990048962825668835325234200766245086213177344000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("71569457046263802294811533723186532165584657342365752577109445058227039255480148842668944867280814080000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("5797126020747367985879734231578109105412357244731625958745865049716390179693892056256184534249745940480000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("475364333701284174842138206989404946643813294067993328617160934076743994734899148613007131808479167119360000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("39455239697206586511897471180120610571436503407643446275224357528369751562996629334879591940103770870906880000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("3314240134565353266999387579130131288000666286242049487118846032383059131291716864129885722968716753156177920000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("281710411438055027694947944226061159480056634330574206405101912752560026159795933451040286452340924018275123200000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("24227095383672732381765523203441259715284870552429381750838764496720162249742450276789464634901319465571660595200000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("2107757298379527717213600518699389595229783738061356212322972511214654115727593174080683423236414793504734471782400000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("185482642257398439114796845645546284380220968949399346684421580986889562184028199319100141244804501828416633516851200000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("16507955160908461081216919262453619309839666236496541854913520707833171034378509739399912570787600662729080382999756800000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("1485715964481761497309522733620825737885569961284688766942216863704985393094065876545992131370884059645617234469978112000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("135200152767840296255166568759495142147586866476906677791741734597153670771559994765685283954750449427751168336768008192000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("12438414054641307255475324325873553077577991715875414356840239582938137710983519518443046123837041347353107486982656753664000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("1156772507081641574759205162306240436214753229576413535186142281213246807121467315215203289516844845303838996289387078090752000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("108736615665674308027365285256786601004186803580182872307497374434045199869417927630229109214583415458560865651202385340530688000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("10329978488239059262599702099394727095397746340117372869212250571234293987594703124871765375385424468563282236864226607350415360000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("991677934870949689209571401541893801158183648651267795444376054838492222809091499987689476037000748982075094738965754305639874560000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("96192759682482119853328425949563698712343813919172976158104477319333745612481875498805879175589072651261284189679678167647067832320000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("9426890448883247745626185743057242473809693764078951663494238777294707070023223798882976159207729119823605850588608460429412647567360000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000")),
|
||||
T(boost::math::tools::convert_from_string<T>("93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000")),
|
||||
}};
|
||||
|
||||
return factorials[i];
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T unchecked_factorial_imp(unsigned i, const mpl::int_<0>&)
|
||||
{
|
||||
BOOST_STATIC_ASSERT(!boost::is_integral<T>::value);
|
||||
// factorial<unsigned int>(n) is not implemented
|
||||
// because it would overflow integral type T for too small n
|
||||
// to be useful. Use instead a floating-point type,
|
||||
// and convert to an unsigned type if essential, for example:
|
||||
// unsigned int nfac = static_cast<unsigned int>(factorial<double>(n));
|
||||
// See factorial documentation for more detail.
|
||||
#ifdef BOOST_NO_CXX11_THREAD_LOCAL
|
||||
unchecked_factorial_initializer<T>::force_instantiate();
|
||||
#endif
|
||||
static const char* const factorial_strings[] = {
|
||||
"1",
|
||||
"1",
|
||||
"2",
|
||||
"6",
|
||||
"24",
|
||||
"120",
|
||||
"720",
|
||||
"5040",
|
||||
"40320",
|
||||
"362880",
|
||||
"3628800",
|
||||
"39916800",
|
||||
"479001600",
|
||||
"6227020800",
|
||||
"87178291200",
|
||||
"1307674368000",
|
||||
"20922789888000",
|
||||
"355687428096000",
|
||||
"6402373705728000",
|
||||
"121645100408832000",
|
||||
"2432902008176640000",
|
||||
"51090942171709440000",
|
||||
"1124000727777607680000",
|
||||
"25852016738884976640000",
|
||||
"620448401733239439360000",
|
||||
"15511210043330985984000000",
|
||||
"403291461126605635584000000",
|
||||
"10888869450418352160768000000",
|
||||
"304888344611713860501504000000",
|
||||
"8841761993739701954543616000000",
|
||||
"265252859812191058636308480000000",
|
||||
"8222838654177922817725562880000000",
|
||||
"263130836933693530167218012160000000",
|
||||
"8683317618811886495518194401280000000",
|
||||
"295232799039604140847618609643520000000",
|
||||
"10333147966386144929666651337523200000000",
|
||||
"371993326789901217467999448150835200000000",
|
||||
"13763753091226345046315979581580902400000000",
|
||||
"523022617466601111760007224100074291200000000",
|
||||
"20397882081197443358640281739902897356800000000",
|
||||
"815915283247897734345611269596115894272000000000",
|
||||
"33452526613163807108170062053440751665152000000000",
|
||||
"1405006117752879898543142606244511569936384000000000",
|
||||
"60415263063373835637355132068513997507264512000000000",
|
||||
"2658271574788448768043625811014615890319638528000000000",
|
||||
"119622220865480194561963161495657715064383733760000000000",
|
||||
"5502622159812088949850305428800254892961651752960000000000",
|
||||
"258623241511168180642964355153611979969197632389120000000000",
|
||||
"12413915592536072670862289047373375038521486354677760000000000",
|
||||
"608281864034267560872252163321295376887552831379210240000000000",
|
||||
"30414093201713378043612608166064768844377641568960512000000000000",
|
||||
"1551118753287382280224243016469303211063259720016986112000000000000",
|
||||
"80658175170943878571660636856403766975289505440883277824000000000000",
|
||||
"4274883284060025564298013753389399649690343788366813724672000000000000",
|
||||
"230843697339241380472092742683027581083278564571807941132288000000000000",
|
||||
"12696403353658275925965100847566516959580321051449436762275840000000000000",
|
||||
"710998587804863451854045647463724949736497978881168458687447040000000000000",
|
||||
"40526919504877216755680601905432322134980384796226602145184481280000000000000",
|
||||
"2350561331282878571829474910515074683828862318181142924420699914240000000000000",
|
||||
"138683118545689835737939019720389406345902876772687432540821294940160000000000000",
|
||||
"8320987112741390144276341183223364380754172606361245952449277696409600000000000000",
|
||||
"507580213877224798800856812176625227226004528988036003099405939480985600000000000000",
|
||||
"31469973260387937525653122354950764088012280797258232192163168247821107200000000000000",
|
||||
"1982608315404440064116146708361898137544773690227268628106279599612729753600000000000000",
|
||||
"126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000",
|
||||
"8247650592082470666723170306785496252186258551345437492922123134388955774976000000000000000",
|
||||
"544344939077443064003729240247842752644293064388798874532860126869671081148416000000000000000",
|
||||
"36471110918188685288249859096605464427167635314049524593701628500267962436943872000000000000000",
|
||||
"2480035542436830599600990418569171581047399201355367672371710738018221445712183296000000000000000",
|
||||
"171122452428141311372468338881272839092270544893520369393648040923257279754140647424000000000000000",
|
||||
"11978571669969891796072783721689098736458938142546425857555362864628009582789845319680000000000000000",
|
||||
"850478588567862317521167644239926010288584608120796235886430763388588680378079017697280000000000000000",
|
||||
"61234458376886086861524070385274672740778091784697328983823014963978384987221689274204160000000000000000",
|
||||
"4470115461512684340891257138125051110076800700282905015819080092370422104067183317016903680000000000000000",
|
||||
"330788544151938641225953028221253782145683251820934971170611926835411235700971565459250872320000000000000000",
|
||||
"24809140811395398091946477116594033660926243886570122837795894512655842677572867409443815424000000000000000000",
|
||||
"1885494701666050254987932260861146558230394535379329335672487982961844043495537923117729972224000000000000000000",
|
||||
"145183092028285869634070784086308284983740379224208358846781574688061991349156420080065207861248000000000000000000",
|
||||
"11324281178206297831457521158732046228731749579488251990048962825668835325234200766245086213177344000000000000000000",
|
||||
"894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000",
|
||||
"71569457046263802294811533723186532165584657342365752577109445058227039255480148842668944867280814080000000000000000000",
|
||||
"5797126020747367985879734231578109105412357244731625958745865049716390179693892056256184534249745940480000000000000000000",
|
||||
"475364333701284174842138206989404946643813294067993328617160934076743994734899148613007131808479167119360000000000000000000",
|
||||
"39455239697206586511897471180120610571436503407643446275224357528369751562996629334879591940103770870906880000000000000000000",
|
||||
"3314240134565353266999387579130131288000666286242049487118846032383059131291716864129885722968716753156177920000000000000000000",
|
||||
"281710411438055027694947944226061159480056634330574206405101912752560026159795933451040286452340924018275123200000000000000000000",
|
||||
"24227095383672732381765523203441259715284870552429381750838764496720162249742450276789464634901319465571660595200000000000000000000",
|
||||
"2107757298379527717213600518699389595229783738061356212322972511214654115727593174080683423236414793504734471782400000000000000000000",
|
||||
"185482642257398439114796845645546284380220968949399346684421580986889562184028199319100141244804501828416633516851200000000000000000000",
|
||||
"16507955160908461081216919262453619309839666236496541854913520707833171034378509739399912570787600662729080382999756800000000000000000000",
|
||||
"1485715964481761497309522733620825737885569961284688766942216863704985393094065876545992131370884059645617234469978112000000000000000000000",
|
||||
"135200152767840296255166568759495142147586866476906677791741734597153670771559994765685283954750449427751168336768008192000000000000000000000",
|
||||
"12438414054641307255475324325873553077577991715875414356840239582938137710983519518443046123837041347353107486982656753664000000000000000000000",
|
||||
"1156772507081641574759205162306240436214753229576413535186142281213246807121467315215203289516844845303838996289387078090752000000000000000000000",
|
||||
"108736615665674308027365285256786601004186803580182872307497374434045199869417927630229109214583415458560865651202385340530688000000000000000000000",
|
||||
"10329978488239059262599702099394727095397746340117372869212250571234293987594703124871765375385424468563282236864226607350415360000000000000000000000",
|
||||
"991677934870949689209571401541893801158183648651267795444376054838492222809091499987689476037000748982075094738965754305639874560000000000000000000000",
|
||||
"96192759682482119853328425949563698712343813919172976158104477319333745612481875498805879175589072651261284189679678167647067832320000000000000000000000",
|
||||
"9426890448883247745626185743057242473809693764078951663494238777294707070023223798882976159207729119823605850588608460429412647567360000000000000000000000",
|
||||
"933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000",
|
||||
"93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000",
|
||||
};
|
||||
|
||||
static BOOST_MATH_THREAD_LOCAL T factorials[sizeof(factorial_strings) / sizeof(factorial_strings[0])];
|
||||
static BOOST_MATH_THREAD_LOCAL int digits = 0;
|
||||
|
||||
int current_digits = boost::math::tools::digits<T>();
|
||||
|
||||
if(digits != current_digits)
|
||||
{
|
||||
digits = current_digits;
|
||||
for(unsigned k = 0; k < sizeof(factorials) / sizeof(factorials[0]); ++k)
|
||||
factorials[k] = static_cast<T>(boost::math::tools::convert_from_string<T>(factorial_strings[k]));
|
||||
}
|
||||
|
||||
return factorials[i];
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T unchecked_factorial(unsigned i)
|
||||
{
|
||||
typedef typename boost::math::policies::precision<T, boost::math::policies::policy<> >::type tag_type;
|
||||
return unchecked_factorial_imp<T>(i, tag_type());
|
||||
}
|
||||
|
||||
template <class T>
|
||||
struct max_factorial
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(unsigned, value = 100);
|
||||
};
|
||||
|
||||
#else // BOOST_MATH_NO_LEXICAL_CAST
|
||||
|
||||
template <class T>
|
||||
inline T unchecked_factorial(unsigned i BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(T))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
struct max_factorial
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(unsigned, value = 0);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
template <class T>
|
||||
const unsigned max_factorial<T>::value;
|
||||
#endif
|
||||
|
||||
} // namespace math
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_MATH_SP_UC_FACTORIALS_HPP
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
subroutine graycode65(dat,n,idir)
|
||||
|
||||
integer dat(n)
|
||||
do i=1,n
|
||||
dat(i)=igray(dat(i),idir)
|
||||
enddo
|
||||
|
||||
return
|
||||
end subroutine graycode65
|
||||
@@ -0,0 +1,833 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2004 Angus Leeming
|
||||
Copyright (c) 2004 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)
|
||||
==============================================================================*/
|
||||
#ifndef BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
|
||||
#define BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
|
||||
|
||||
#include <boost/phoenix/core/limits.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/void.hpp>
|
||||
#include <boost/phoenix/stl/container/detail/container.hpp>
|
||||
#include <boost/phoenix/function/adapt_callable.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
|
||||
namespace boost { namespace phoenix
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// STL container member functions
|
||||
//
|
||||
// Lazy functions for STL container member functions
|
||||
//
|
||||
// These functions provide a mechanism for the lazy evaluation of the
|
||||
// public member functions of the STL containers. For an overview of
|
||||
// what is meant by 'lazy evaluation', see the comments in operators.hpp
|
||||
// and functions.hpp.
|
||||
//
|
||||
// Lazy functions are provided for all of the member functions of the
|
||||
// following containers:
|
||||
//
|
||||
// deque - list - map - multimap - vector.
|
||||
//
|
||||
// Indeed, should *your* class have member functions with the same names
|
||||
// and signatures as those listed below, then it will automatically be
|
||||
// supported. To summarize, lazy functions are provided for member
|
||||
// functions:
|
||||
//
|
||||
// assign - at - back - begin - capacity - clear - empty - end -
|
||||
// erase - front - get_allocator - insert - key_comp - max_size -
|
||||
// pop_back - pop_front - push_back - push_front - rbegin - rend -
|
||||
// reserve - resize . size - splice - value_comp.
|
||||
//
|
||||
// The lazy functions' names are the same as the corresponding member
|
||||
// function. Sample usage:
|
||||
//
|
||||
// "Normal" version "Lazy" version
|
||||
// ---------------- --------------
|
||||
// my_vector.at(5) phoenix::at(arg1, 5)
|
||||
// my_list.size() phoenix::size(arg1)
|
||||
// my_vector1.swap(my_vector2) phoenix::swap(arg1, arg2)
|
||||
//
|
||||
// Notice that member functions with names that clash with a
|
||||
// function in stl algorithms are absent. This will be provided
|
||||
// in Phoenix's algorithm module.
|
||||
//
|
||||
// No support is provided here for lazy versions of operator+=,
|
||||
// operator[] etc. Such operators are not specific to STL containers and
|
||||
// lazy versions can therefore be found in operators.hpp.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Lazy member function implementaions.
|
||||
//
|
||||
// The structs below provide the guts of the implementation. Thereafter,
|
||||
// the corresponding lazy function itself is simply:
|
||||
//
|
||||
// function<stl::assign> const assign = stl::assign();
|
||||
//
|
||||
// The structs provide a nested "result" class template whose
|
||||
// "type" typedef enables the lazy function to ascertain the type
|
||||
// to be returned when it is invoked.
|
||||
//
|
||||
// They also provide operator() member functions with signatures
|
||||
// corresponding to those of the underlying member function of
|
||||
// the STL container.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace stl
|
||||
{
|
||||
struct assign
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <
|
||||
typename This
|
||||
, typename C
|
||||
, typename Arg1
|
||||
>
|
||||
struct result<This(C&, Arg1&)>
|
||||
{
|
||||
typedef typename add_reference<C>::type type;
|
||||
};
|
||||
|
||||
template <
|
||||
typename This
|
||||
, typename C
|
||||
, typename Arg1
|
||||
, typename Arg2
|
||||
>
|
||||
struct result<This(C&, Arg1, Arg2)>
|
||||
{
|
||||
typedef typename add_reference<C>::type type;
|
||||
};
|
||||
|
||||
template <
|
||||
typename This
|
||||
, typename C
|
||||
, typename Arg1
|
||||
, typename Arg2
|
||||
, typename Arg3
|
||||
>
|
||||
struct result<This(C&, Arg1, Arg2, Arg3)>
|
||||
{
|
||||
typedef typename add_reference<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C, typename Arg1>
|
||||
C& operator()(C& c, Arg1 const & arg1) const
|
||||
{
|
||||
c.assign(arg1);
|
||||
return c;
|
||||
}
|
||||
|
||||
template <typename C, typename Arg1, typename Arg2>
|
||||
C& operator()(C& c, Arg1 arg1, Arg2 arg2) const
|
||||
{
|
||||
c.assign(arg1, arg2);
|
||||
return c;
|
||||
}
|
||||
|
||||
template <typename C, typename Arg1, typename Arg2, typename Arg3>
|
||||
C& operator()(
|
||||
C& c
|
||||
, Arg1 arg1
|
||||
, Arg2 arg2
|
||||
, Arg3 const & arg3
|
||||
) const
|
||||
{
|
||||
return c.assign(arg1, arg2, arg3);
|
||||
}
|
||||
};
|
||||
|
||||
struct at_impl
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C, typename Index>
|
||||
struct result<This(C&, Index)>
|
||||
{
|
||||
//typedef typename const_qualified_reference_of<C>::type type;
|
||||
typedef typename C::value_type & type;
|
||||
};
|
||||
|
||||
template <typename C, typename Index>
|
||||
typename result<at_impl(C&, Index const&)>::type
|
||||
operator()(C& c, Index const &i) const
|
||||
{
|
||||
return c.at(i);
|
||||
}
|
||||
|
||||
template <typename This, typename C, typename Index>
|
||||
struct result<This(C const&, Index)>
|
||||
{
|
||||
typedef typename C::value_type const & type;
|
||||
};
|
||||
|
||||
template <typename C, typename Index>
|
||||
typename result<at_impl(C const&, Index const&)>::type
|
||||
operator()(C const& c, Index const &i) const
|
||||
{
|
||||
return c.at(i);
|
||||
}
|
||||
};
|
||||
|
||||
struct back
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef
|
||||
typename const_qualified_reference_of<C>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<back(C&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.back();
|
||||
}
|
||||
};
|
||||
|
||||
struct begin
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename const_qualified_iterator_of<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<begin(C&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.begin();
|
||||
}
|
||||
};
|
||||
|
||||
struct capacity
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename size_type_of<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<capacity(C&)>::type
|
||||
operator()(C const& c) const
|
||||
{
|
||||
return c.capacity();
|
||||
}
|
||||
};
|
||||
|
||||
struct clear
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C>
|
||||
void operator()(C& c) const
|
||||
{
|
||||
return c.clear();
|
||||
}
|
||||
};
|
||||
|
||||
struct empty
|
||||
{
|
||||
typedef bool result_type;
|
||||
|
||||
template <typename C>
|
||||
bool operator()(C const& c) const
|
||||
{
|
||||
return c.empty();
|
||||
}
|
||||
};
|
||||
|
||||
struct end
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename const_qualified_iterator_of<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<end(C&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.end();
|
||||
}
|
||||
};
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename C, typename Arg1, typename Arg2 = mpl::void_>
|
||||
struct erase
|
||||
{
|
||||
// BOOST_MSVC #if branch here in map_erase_result non-
|
||||
// standard behavior. The return type should be void but
|
||||
// VC7.1 prefers to return iterator_of<C>. As a result,
|
||||
// VC7.1 complains of error C2562:
|
||||
// boost::phoenix::stl::erase::operator() 'void' function
|
||||
// returning a value. Oh well... :*
|
||||
|
||||
typedef
|
||||
boost::mpl::eval_if_c<
|
||||
boost::is_same<
|
||||
typename remove_reference<Arg1>::type
|
||||
, typename iterator_of<C>::type
|
||||
>::value
|
||||
#if defined(BOOST_MSVC)// && (BOOST_MSVC <= 1500)
|
||||
, iterator_of<C>
|
||||
#else
|
||||
, boost::mpl::identity<void>
|
||||
#endif
|
||||
, size_type_of<C>
|
||||
>
|
||||
map_erase_result;
|
||||
|
||||
typedef typename
|
||||
boost::mpl::eval_if_c<
|
||||
has_mapped_type<C>::value
|
||||
, map_erase_result
|
||||
, iterator_of<C>
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
}
|
||||
|
||||
struct erase
|
||||
{
|
||||
// This mouthful can differentiate between the generic erase
|
||||
// functions (Container == std::deque, std::list, std::vector) and
|
||||
// that specific to the two map-types, std::map and std::multimap.
|
||||
//
|
||||
// where C is a std::deque, std::list, std::vector:
|
||||
//
|
||||
// 1) iterator C::erase(iterator where);
|
||||
// 2) iterator C::erase(iterator first, iterator last);
|
||||
//
|
||||
// where M is a std::map or std::multimap:
|
||||
//
|
||||
// 3) size_type M::erase(const Key& keyval);
|
||||
// 4) void M::erase(iterator where);
|
||||
// 5) void M::erase(iterator first, iterator last);
|
||||
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C, typename Arg1>
|
||||
struct result<This(C&, Arg1)>
|
||||
: result_of::erase<C, Arg1>
|
||||
{};
|
||||
|
||||
template <typename This, typename C, typename Arg1, typename Arg2>
|
||||
struct result<This(C&, Arg1, Arg2)>
|
||||
: result_of::erase<C, Arg1, Arg2>
|
||||
{};
|
||||
|
||||
template <typename C, typename Arg1>
|
||||
typename result_of::erase<C, Arg1>::type
|
||||
operator()(C& c, Arg1 arg1) const
|
||||
{
|
||||
typedef typename result_of::erase<C, Arg1>::type result_type;
|
||||
return static_cast<result_type>(c.erase(arg1));
|
||||
}
|
||||
|
||||
template <typename C, typename Arg1, typename Arg2>
|
||||
typename result_of::erase<C, Arg1, Arg2>::type
|
||||
operator()(C& c, Arg1 arg1, Arg2 arg2) const
|
||||
{
|
||||
typedef typename result_of::erase<C, Arg1, Arg2>::type result_type;
|
||||
return static_cast<result_type>(c.erase(arg1, arg2));
|
||||
}
|
||||
};
|
||||
|
||||
struct front
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename const_qualified_reference_of<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<front(C&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.front();
|
||||
}
|
||||
};
|
||||
|
||||
struct get_allocator
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename allocator_type_of<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<get_allocator(C const&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.get_allocator();
|
||||
}
|
||||
};
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <
|
||||
typename C
|
||||
, typename Arg1
|
||||
, typename Arg2 = mpl::void_
|
||||
, typename Arg3 = mpl::void_
|
||||
>
|
||||
class insert
|
||||
{
|
||||
struct pair_iterator_bool
|
||||
{
|
||||
typedef typename std::pair<typename C::iterator, bool> type;
|
||||
};
|
||||
|
||||
typedef
|
||||
boost::mpl::eval_if<
|
||||
map_insert_returns_pair<typename remove_const<C>::type>
|
||||
, pair_iterator_bool
|
||||
, iterator_of<C>
|
||||
>
|
||||
choice_1;
|
||||
|
||||
typedef
|
||||
boost::mpl::eval_if_c<
|
||||
boost::mpl::and_<
|
||||
boost::is_same<Arg3, mpl::void_>
|
||||
, boost::mpl::not_<boost::is_same<Arg1, Arg2> >
|
||||
>::value
|
||||
, iterator_of<C>
|
||||
, boost::mpl::identity<void>
|
||||
>
|
||||
choice_2;
|
||||
|
||||
public:
|
||||
|
||||
typedef typename
|
||||
boost::mpl::eval_if_c<
|
||||
boost::is_same<Arg2, mpl::void_>::value
|
||||
, choice_1
|
||||
, choice_2
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
}
|
||||
|
||||
struct insert
|
||||
{
|
||||
// This mouthful can differentiate between the generic insert
|
||||
// functions (Container == deque, list, vector) and those
|
||||
// specific to the two map-types, std::map and std::multimap.
|
||||
//
|
||||
// where C is a std::deque, std::list, std::vector:
|
||||
//
|
||||
// 1) iterator C::insert(iterator where, value_type value);
|
||||
// 2) void C::insert(
|
||||
// iterator where, size_type count, value_type value);
|
||||
// 3) template <typename Iter>
|
||||
// void C::insert(iterator where, Iter first, Iter last);
|
||||
//
|
||||
// where M is a std::map and MM is a std::multimap:
|
||||
//
|
||||
// 4) pair<iterator, bool> M::insert(value_type const&);
|
||||
// 5) iterator MM::insert(value_type const&);
|
||||
//
|
||||
// where M is a std::map or std::multimap:
|
||||
//
|
||||
// 6) template <typename Iter>
|
||||
// void M::insert(Iter first, Iter last);
|
||||
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <
|
||||
typename This
|
||||
, typename C
|
||||
, typename Arg1
|
||||
>
|
||||
struct result<This(C &, Arg1)>
|
||||
: result_of::insert<C, Arg1>
|
||||
{};
|
||||
|
||||
template <
|
||||
typename This
|
||||
, typename C
|
||||
, typename Arg1
|
||||
, typename Arg2
|
||||
>
|
||||
struct result<This(C &, Arg1, Arg2)>
|
||||
: result_of::insert<C, Arg1, Arg2>
|
||||
{};
|
||||
|
||||
template <
|
||||
typename This
|
||||
, typename C
|
||||
, typename Arg1
|
||||
, typename Arg2
|
||||
, typename Arg3
|
||||
>
|
||||
struct result<This(C &, Arg1, Arg2, Arg3)>
|
||||
: result_of::insert<C, Arg1, Arg2, Arg3>
|
||||
{};
|
||||
|
||||
template <typename C, typename Arg1>
|
||||
typename result<insert(C&, Arg1)>::type
|
||||
operator()(C& c, Arg1 arg1) const
|
||||
{
|
||||
return c.insert(arg1);
|
||||
}
|
||||
|
||||
template <typename C, typename Arg1, typename Arg2>
|
||||
typename result<insert(C&, Arg1, Arg2)>::type
|
||||
operator()(C& c, Arg1 arg1, Arg2 arg2) const
|
||||
{
|
||||
typedef typename result<insert(C&, Arg1, Arg2)>::type result_type;
|
||||
return static_cast<result_type>(c.insert(arg1, arg2));
|
||||
}
|
||||
|
||||
template <typename C, typename Arg1, typename Arg2, typename Arg3>
|
||||
typename result<insert(C&, Arg1, Arg2, Arg3)>::type
|
||||
operator()(C& c, Arg1 arg1, Arg2 arg2, Arg3 arg3) const
|
||||
{
|
||||
typedef typename result<insert(C&, Arg1, Arg2, Arg3)>::type result_type;
|
||||
return static_cast<result_type>(c.insert(arg1, arg2, arg3));
|
||||
}
|
||||
};
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename C>
|
||||
struct key_comp
|
||||
{
|
||||
typedef typename key_compare_of<C>::type type;
|
||||
};
|
||||
}
|
||||
|
||||
struct key_comp
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
: result_of::key_comp<C>
|
||||
{};
|
||||
|
||||
template <typename C>
|
||||
typename result_of::key_comp<C>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.key_comp();
|
||||
}
|
||||
};
|
||||
|
||||
struct max_size
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename size_type_of<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<max_size(C const&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.max_size();
|
||||
}
|
||||
};
|
||||
|
||||
struct pop_back
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C>
|
||||
void operator()(C& c) const
|
||||
{
|
||||
return c.pop_back();
|
||||
}
|
||||
};
|
||||
|
||||
struct pop_front
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C>
|
||||
void operator()(C& c) const
|
||||
{
|
||||
return c.pop_front();
|
||||
}
|
||||
};
|
||||
|
||||
struct push_back
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C, typename Arg>
|
||||
void operator()(C& c, Arg const& data) const
|
||||
{
|
||||
return c.push_back(data);
|
||||
}
|
||||
};
|
||||
|
||||
struct push_front
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C, typename Arg>
|
||||
void operator()(C& c, Arg const& data) const
|
||||
{
|
||||
return c.push_front(data);
|
||||
}
|
||||
};
|
||||
|
||||
struct rbegin
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename
|
||||
const_qualified_reverse_iterator_of<C>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<rbegin(C&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.rbegin();
|
||||
}
|
||||
};
|
||||
|
||||
struct rend
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename
|
||||
const_qualified_reverse_iterator_of<C>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<rend(C&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.rend();
|
||||
}
|
||||
};
|
||||
|
||||
struct reserve
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C, typename Arg>
|
||||
void operator()(C& c, Arg const& count) const
|
||||
{
|
||||
c.reserve(count);
|
||||
}
|
||||
};
|
||||
|
||||
struct resize
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C, typename Arg1>
|
||||
void operator()(C& c, Arg1 const& arg1) const
|
||||
{
|
||||
c.resize(arg1);
|
||||
}
|
||||
|
||||
template <typename C, typename Arg1, typename Arg2>
|
||||
void operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
|
||||
{
|
||||
c.resize(arg1, arg2);
|
||||
}
|
||||
};
|
||||
|
||||
struct size
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
{
|
||||
typedef typename size_type_of<C>::type type;
|
||||
};
|
||||
|
||||
template <typename C>
|
||||
typename result<size(C&)>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.size();
|
||||
}
|
||||
};
|
||||
|
||||
struct splice
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
template <typename C, typename Arg1, typename Arg2>
|
||||
void operator()(C& c, Arg1 arg1, Arg2 &arg2) const
|
||||
{
|
||||
c.splice(arg1, arg2);
|
||||
}
|
||||
|
||||
template <
|
||||
typename C
|
||||
, typename Arg1
|
||||
, typename Arg2
|
||||
, typename Arg3
|
||||
>
|
||||
void operator()(
|
||||
C& c
|
||||
, Arg1 arg1
|
||||
, Arg2 & arg2
|
||||
, Arg3 arg3
|
||||
) const
|
||||
{
|
||||
c.splice(arg1, arg2, arg3);
|
||||
}
|
||||
|
||||
template <
|
||||
typename C
|
||||
, typename Arg1
|
||||
, typename Arg2
|
||||
, typename Arg3
|
||||
, typename Arg4
|
||||
>
|
||||
void operator()(
|
||||
C c
|
||||
, Arg1 arg1
|
||||
, Arg2 & arg2
|
||||
, Arg3 arg3
|
||||
, Arg4 arg4
|
||||
) const
|
||||
{
|
||||
c.splice(arg1, arg2, arg3, arg4);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename C>
|
||||
struct value_comp
|
||||
{
|
||||
typedef typename value_compare_of<C>::type type;
|
||||
};
|
||||
}
|
||||
|
||||
struct value_comp
|
||||
{
|
||||
template <typename Sig>
|
||||
struct result;
|
||||
|
||||
template <typename This, typename C>
|
||||
struct result<This(C&)>
|
||||
: result_of::value_comp<C>
|
||||
{};
|
||||
|
||||
template <typename C>
|
||||
typename result_of::value_comp<C>::type
|
||||
operator()(C& c) const
|
||||
{
|
||||
return c.value_comp();
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace stl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// The lazy functions themselves.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace adl_barrier
|
||||
{
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 3)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 4)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(at, ::boost::phoenix::stl::at_impl, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(back, stl::back, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(begin, stl::begin, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(capacity, stl::capacity, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(clear, stl::clear, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(empty, stl::empty, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(end, stl::end, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 3)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(front, stl::front, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(get_allocator, stl::get_allocator, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 3)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 4)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(key_comp, stl::key_comp, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(max_size, stl::max_size, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(pop_back, stl::pop_back, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(pop_front, stl::pop_front, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(push_back, stl::push_back, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(push_front, stl::push_front, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(rbegin, stl::rbegin, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(rend, stl::rend, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(reserve, stl::reserve, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 3)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(size, stl::size, 1)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 2)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 3)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 4)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 5)
|
||||
BOOST_PHOENIX_ADAPT_CALLABLE(value_comp, stl::value_comp, 1)
|
||||
}
|
||||
|
||||
using namespace phoenix::adl_barrier;
|
||||
}} // namespace boost::phoenix
|
||||
|
||||
#endif // BOOST_PHOENIX_STL_CONTAINERS_HPP
|
||||
@@ -0,0 +1,117 @@
|
||||
#-------------------------------------------------
|
||||
#
|
||||
# Project created by QtCreator 2011-07-07T08:39:24
|
||||
#
|
||||
#-------------------------------------------------
|
||||
|
||||
QT += network multimedia
|
||||
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
|
||||
CONFIG += thread
|
||||
#CONFIG += console
|
||||
|
||||
TARGET = wsjtx
|
||||
VERSION = "Not for Release"
|
||||
TEMPLATE = app
|
||||
DEFINES = QT5
|
||||
QMAKE_CXXFLAGS += -std=c++11
|
||||
DEFINES += PROJECT_MANUAL="'\"http://www.physics.princeton.edu/pulsar/K1JT/wsjtx-doc/wsjtx-main.html\"'"
|
||||
|
||||
isEmpty (DESTDIR) {
|
||||
DESTDIR = ../wsjtx_exp_install
|
||||
}
|
||||
|
||||
isEmpty (HAMLIB_DIR) {
|
||||
HAMLIB_DIR = ../../hamlib3/mingw32
|
||||
}
|
||||
|
||||
isEmpty (FFTW3_DIR) {
|
||||
FFTW3_DIR = .
|
||||
}
|
||||
|
||||
F90 = gfortran
|
||||
gfortran.output = ${QMAKE_FILE_BASE}.o
|
||||
gfortran.commands = $$F90 -c -O2 -o ${QMAKE_FILE_OUT} ${QMAKE_FILE_NAME}
|
||||
gfortran.input = F90_SOURCES
|
||||
QMAKE_EXTRA_COMPILERS += gfortran
|
||||
|
||||
win32 {
|
||||
DEFINES += WIN32
|
||||
QT += axcontainer
|
||||
TYPELIBS = $$system(dumpcpp -getfile {4FE359C5-A58F-459D-BE95-CA559FB4F270})
|
||||
}
|
||||
|
||||
unix {
|
||||
DEFINES += UNIX
|
||||
}
|
||||
|
||||
#
|
||||
# Order matters here as the link is in this order so referrers need to be after referred
|
||||
#
|
||||
SOURCES += \
|
||||
logbook/adif.cpp \
|
||||
logbook/countrydat.cpp \
|
||||
logbook/countriesworked.cpp \
|
||||
logbook/logbook.cpp \
|
||||
astro.cpp Radio.cpp NetworkServerLookup.cpp revision_utils.cpp \
|
||||
Transceiver.cpp TransceiverBase.cpp TransceiverFactory.cpp \
|
||||
PollingTransceiver.cpp EmulateSplitTransceiver.cpp LettersSpinBox.cpp \
|
||||
HRDTransceiver.cpp DXLabSuiteCommanderTransceiver.cpp \
|
||||
HamlibTransceiver.cpp FrequencyLineEdit.cpp Bands.cpp \
|
||||
FrequencyList.cpp StationList.cpp ForeignKeyDelegate.cpp \
|
||||
FrequencyItemDelegate.cpp LiveFrequencyValidator.cpp \
|
||||
Configuration.cpp psk_reporter.cpp AudioDevice.cpp \
|
||||
Modulator.cpp Detector.cpp logqso.cpp displaytext.cpp \
|
||||
getfile.cpp soundout.cpp soundin.cpp meterwidget.cpp signalmeter.cpp \
|
||||
WFPalette.cpp plotter.cpp widegraph.cpp about.cpp WsprTxScheduler.cpp mainwindow.cpp \
|
||||
main.cpp decodedtext.cpp wsprnet.cpp messageaveraging.cpp \
|
||||
echoplot.cpp echograph.cpp fastgraph.cpp fastplot.cpp Modes.cpp \
|
||||
WSPRBandHopping.cpp MessageAggregator.cpp SampleDownloader.cpp qt_helpers.cpp\
|
||||
MultiSettings.cpp PhaseEqualizationDialog.cpp
|
||||
|
||||
HEADERS += qt_helpers.hpp \
|
||||
pimpl_h.hpp pimpl_impl.hpp \
|
||||
Radio.hpp NetworkServerLookup.hpp revision_utils.hpp \
|
||||
mainwindow.h plotter.h soundin.h soundout.h astro.h \
|
||||
about.h WFPalette.hpp widegraph.h getfile.h decodedtext.h \
|
||||
commons.h sleep.h displaytext.h logqso.h LettersSpinBox.hpp \
|
||||
Bands.hpp FrequencyList.hpp StationList.hpp ForeignKeyDelegate.hpp FrequencyItemDelegate.hpp LiveFrequencyValidator.hpp \
|
||||
FrequencyLineEdit.hpp AudioDevice.hpp Detector.hpp Modulator.hpp psk_reporter.h \
|
||||
Transceiver.hpp TransceiverBase.hpp TransceiverFactory.hpp PollingTransceiver.hpp \
|
||||
EmulateSplitTransceiver.hpp DXLabSuiteCommanderTransceiver.hpp HamlibTransceiver.hpp \
|
||||
Configuration.hpp wsprnet.h signalmeter.h meterwidget.h \
|
||||
logbook/logbook.h logbook/countrydat.h logbook/countriesworked.h logbook/adif.h \
|
||||
messageaveraging.h echoplot.h echograph.h fastgraph.h fastplot.h Modes.hpp WSPRBandHopping.hpp \
|
||||
WsprTxScheduler.h SampleDownloader.hpp MultiSettings.hpp PhaseEqualizationDialog.hpp
|
||||
|
||||
INCLUDEPATH += qmake_only
|
||||
|
||||
win32 {
|
||||
SOURCES += killbyname.cpp OmniRigTransceiver.cpp
|
||||
HEADERS += OmniRigTransceiver.hpp
|
||||
}
|
||||
|
||||
FORMS += mainwindow.ui about.ui Configuration.ui widegraph.ui astro.ui \
|
||||
logqso.ui wf_palette_design_dialog.ui messageaveraging.ui echograph.ui \
|
||||
fastgraph.ui
|
||||
|
||||
RC_FILE = wsjtx.rc
|
||||
RESOURCES = wsjtx.qrc
|
||||
|
||||
unix {
|
||||
LIBS += -L lib -ljt9
|
||||
LIBS += -lhamlib
|
||||
LIBS += -lfftw3f $$system($$F90 -print-file-name=libgfortran.so)
|
||||
}
|
||||
|
||||
win32 {
|
||||
INCLUDEPATH += $${HAMLIB_DIR}/include
|
||||
INCLUDEPATH += C:\JTSDK\wsjtx_exp\build\Release
|
||||
INCLUDEPATH += C:\JTSDK\hamlib3\include
|
||||
INCLUDEPATH += C:\JTSDK\qt5\5.2.1\mingw48_32\include\QtSerialPort
|
||||
|
||||
LIBS += -L$${HAMLIB_DIR}/lib -lhamlib
|
||||
LIBS += -L./lib -lastro -ljt9
|
||||
LIBS += -L$${FFTW3_DIR} -lfftw3f-3
|
||||
LIBS += -lws2_32
|
||||
LIBS += $$system($$F90 -print-file-name=libgfortran.a)
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/version.hpp
|
||||
|
||||
[begin_description]
|
||||
Defines the current version of odeint.
|
||||
[end_description]
|
||||
|
||||
Copyright 2011-2012 Karsten Ahnert
|
||||
Copyright 2011-2012 Mario Mulansky
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or
|
||||
copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#ifndef BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED
|
||||
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
|
||||
|
||||
#define ODEINT_MAJOR_VERSION 2
|
||||
#define ODEINT_MINOR_VERSION 2
|
||||
#define ODEINT_PATCH_LEVEL 0
|
||||
#define ODEINT_VERSION ( ODEINT_MAJOR_VERSION * 100000 + ODEINT_MINOR_VERSION * 100 + ODEINT_PATCH_LEVEL )
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
namespace version {
|
||||
|
||||
const int major = ODEINT_MAJOR_VERSION ;
|
||||
const int minor = ODEINT_MINOR_VERSION ;
|
||||
const int patch_level = ODEINT_PATCH_LEVEL ;
|
||||
|
||||
}
|
||||
|
||||
inline std::string get_version_string( void )
|
||||
{
|
||||
std::ostringstream str;
|
||||
str << "v" << version::major << "." << version::minor;
|
||||
if( version::patch_level != 0 ) str << "_" << version::patch_level;
|
||||
return str.str();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_VERSION_HPP_INCLUDED
|
||||
@@ -0,0 +1,162 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// (C) Copyright John Maddock 2000.
|
||||
// (C) Copyright Ion Gaztanaga 2005-2012.
|
||||
//
|
||||
// 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/interprocess for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_INTERPROCESS_DETAIL_TYPE_TRAITS_HPP
|
||||
#define BOOST_INTERPROCESS_DETAIL_TYPE_TRAITS_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
# include <boost/config.hpp>
|
||||
#endif
|
||||
#
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/interprocess/detail/config_begin.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace interprocess {
|
||||
namespace ipcdetail {
|
||||
|
||||
struct nat{};
|
||||
|
||||
template<class T>
|
||||
struct remove_reference
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct remove_reference<T&>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct is_reference
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct is_reference<T&>
|
||||
{
|
||||
static const bool value = true;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct is_pointer
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct is_pointer<T*>
|
||||
{
|
||||
static const bool value = true;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct add_reference
|
||||
{
|
||||
typedef T& type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct add_reference<T&>
|
||||
{
|
||||
typedef T& type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct add_reference<void>
|
||||
{
|
||||
typedef nat &type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct add_reference<const void>
|
||||
{
|
||||
typedef const nat &type;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct add_const_reference
|
||||
{ typedef const T &type; };
|
||||
|
||||
template <class T>
|
||||
struct add_const_reference<T&>
|
||||
{ typedef T& type; };
|
||||
|
||||
template<class T>
|
||||
struct remove_const
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct remove_const<const T>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct remove_volatile
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct remove_volatile<volatile T>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct remove_const_volatile
|
||||
{
|
||||
typedef typename remove_const<typename remove_volatile<T>::type>::type type;
|
||||
};
|
||||
|
||||
template <typename T, typename U>
|
||||
struct is_same
|
||||
{
|
||||
typedef char yes_type;
|
||||
struct no_type
|
||||
{
|
||||
char padding[8];
|
||||
};
|
||||
|
||||
template <typename V>
|
||||
static yes_type is_same_tester(V*, V*);
|
||||
static no_type is_same_tester(...);
|
||||
|
||||
static T *t;
|
||||
static U *u;
|
||||
|
||||
static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u));
|
||||
};
|
||||
|
||||
template<class T, class U>
|
||||
struct is_cv_same
|
||||
{
|
||||
static const bool value = is_same< typename remove_const_volatile<T>::type
|
||||
, typename remove_const_volatile<U>::type >::value;
|
||||
};
|
||||
|
||||
} // namespace ipcdetail
|
||||
} //namespace interprocess {
|
||||
} //namespace boost {
|
||||
|
||||
#include <boost/interprocess/detail/config_end.hpp>
|
||||
|
||||
#endif //#ifndef BOOST_INTERPROCESS_DETAIL_TYPE_TRAITS_HPP
|
||||
@@ -0,0 +1,118 @@
|
||||
# /* 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) */
|
||||
#
|
||||
# /* See http://www.boost.org for most recent version. */
|
||||
#
|
||||
# ifndef BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP
|
||||
# define BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP
|
||||
#
|
||||
# include <boost/preprocessor/cat.hpp>
|
||||
# include <boost/preprocessor/config/config.hpp>
|
||||
# include <boost/preprocessor/facilities/overload.hpp>
|
||||
# include <boost/preprocessor/tuple/size.hpp>
|
||||
# include <boost/preprocessor/variadic/size.hpp>
|
||||
#
|
||||
# /* BOOST_PP_TUPLE_TO_LIST */
|
||||
#
|
||||
# if BOOST_PP_VARIADICS
|
||||
# if BOOST_PP_VARIADICS_MSVC
|
||||
# define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_TUPLE_TO_LIST_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__), (__VA_ARGS__))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_I(m, args) BOOST_PP_TUPLE_TO_LIST_II(m, args)
|
||||
# define BOOST_PP_TUPLE_TO_LIST_II(m, args) BOOST_PP_CAT(m ## args,)
|
||||
# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
|
||||
# else
|
||||
# define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__)(__VA_ARGS__)
|
||||
# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple
|
||||
# endif
|
||||
# define BOOST_PP_TUPLE_TO_LIST_O_2(size, tuple) BOOST_PP_TUPLE_TO_LIST_O_1(tuple)
|
||||
# else
|
||||
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
|
||||
# define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_I(size, tuple)
|
||||
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
|
||||
# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s t
|
||||
# else
|
||||
# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_II(BOOST_PP_TUPLE_TO_LIST_ ## s t)
|
||||
# define BOOST_PP_TUPLE_TO_LIST_II(res) res
|
||||
# endif
|
||||
# else
|
||||
# define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_OO((size, tuple))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_OO(par) BOOST_PP_TUPLE_TO_LIST_I ## par
|
||||
# define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s ## t
|
||||
# endif
|
||||
# endif
|
||||
#
|
||||
# define BOOST_PP_TUPLE_TO_LIST_1(e0) (e0, BOOST_PP_NIL)
|
||||
# define BOOST_PP_TUPLE_TO_LIST_2(e0, e1) (e0, (e1, BOOST_PP_NIL))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_3(e0, e1, e2) (e0, (e1, (e2, BOOST_PP_NIL)))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_4(e0, e1, e2, e3) (e0, (e1, (e2, (e3, BOOST_PP_NIL))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_5(e0, e1, e2, e3, e4) (e0, (e1, (e2, (e3, (e4, BOOST_PP_NIL)))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_6(e0, e1, e2, e3, e4, e5) (e0, (e1, (e2, (e3, (e4, (e5, BOOST_PP_NIL))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_7(e0, e1, e2, e3, e4, e5, e6) (e0, (e1, (e2, (e3, (e4, (e5, (e6, BOOST_PP_NIL)))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_8(e0, e1, e2, e3, e4, e5, e6, e7) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, BOOST_PP_NIL))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_9(e0, e1, e2, e3, e4, e5, e6, e7, e8) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, BOOST_PP_NIL)))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_10(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, BOOST_PP_NIL))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_11(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10) (e0, (e1, (e2, (e3, (e4, (e5, (e6, (e7, (e8, (e9, (e10, BOOST_PP_NIL)))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_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, BOOST_PP_NIL)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
# define BOOST_PP_TUPLE_TO_LIST_64(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, (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, BOOST_PP_NIL))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
|
||||
#
|
||||
# endif
|
||||
@@ -0,0 +1,75 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/make_expr.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr.hpp
|
||||
/// Contains overloads of make_expr() free function.
|
||||
//
|
||||
// Copyright 2008 Eric Niebler. Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
BOOST_FORCEINLINE
|
||||
typename lazy_disable_if<
|
||||
is_domain<A0>
|
||||
, result_of::make_expr<
|
||||
Tag
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>
|
||||
>::type const
|
||||
make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a))
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, deduce_domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>()(BOOST_PP_ENUM_PARAMS(N, a));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename C)>
|
||||
BOOST_FORCEINLINE
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const C)
|
||||
>::type const
|
||||
make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const C, &c))
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const C)
|
||||
>()(BOOST_PP_ENUM_PARAMS(N, c));
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,22 @@
|
||||
subroutine pctile(x,npts,npct,xpct)
|
||||
|
||||
parameter (NMAX=100000)
|
||||
real*4 x(npts)
|
||||
real*4 tmp(NMAX)
|
||||
|
||||
if(npts.le.0) then
|
||||
xpct=1.0
|
||||
go to 900
|
||||
endif
|
||||
if(npts.gt.NMAX) stop
|
||||
|
||||
tmp(1:npts)=x
|
||||
call shell(npts,tmp)
|
||||
j=nint(npts*0.01*npct)
|
||||
if(j.lt.1) j=1
|
||||
if(j.gt.npts) j=npts
|
||||
xpct=tmp(j)
|
||||
|
||||
900 continue
|
||||
return
|
||||
end subroutine pctile
|
||||
@@ -0,0 +1,98 @@
|
||||
For this step and the next, you may want to pretend you are K1JT
|
||||
by entering that callsign temporarily as *My Call* on the
|
||||
*Settings | General* tab. Your results should then be identical to
|
||||
those shown in the screen shot below.
|
||||
|
||||
.Open a Wave File:
|
||||
|
||||
- Select *File | Open* and select the file
|
||||
+...\save\samples\JT9\130418_1742.wav+. When the file opens you should
|
||||
see something similar to the following screen shot:
|
||||
|
||||
[[X12]]
|
||||
image::main-ui.png[align="center",alt="Main UI and Wide Graph"]
|
||||
|
||||
.Decoding Overview
|
||||
|
||||
Decoding takes place at the end of a receive sequence and proceeds in
|
||||
two steps. The first decode is done at the selected Rx frequency,
|
||||
indicated by the U-shaped green marker on the waterfall scale.
|
||||
Results appear in both the left (*Band Activity*) and right (*Rx
|
||||
Frequency*) text windows on the main screen. The program then finds
|
||||
and decodes all signals in the selected mode over the displayed
|
||||
frequency range. The red marker on the waterfall scale indicates your
|
||||
Tx frequency.
|
||||
|
||||
Seven JT9 signals are present in the example file, all decodable.
|
||||
When this file was recorded KF4RWA was finishing a QSO with K1JT.
|
||||
Since the green marker was placed at his audio frequency, 1224 Hz, his
|
||||
message `K1JT KF4RWA 73` is decoded first and appears in the *Rx
|
||||
Frequency* window. The *Band Activity* window shows this message plus
|
||||
all decodes at other frequencies. By default lines containing `CQ`
|
||||
are highlighted in green, and lines with *My Call* (in this case K1JT)
|
||||
in red.
|
||||
|
||||
[[X13]]
|
||||
.Decoding Controls
|
||||
|
||||
To gain some feeling for controls frequently used when making QSOs,
|
||||
try clicking with the mouse on the decoded text lines and on the
|
||||
waterfall spectral display. You should be able to confirm the
|
||||
following behavior:
|
||||
|
||||
- Double-click on either of the decoded lines highlighted in
|
||||
green. This action produces the following results:
|
||||
|
||||
** Callsign and locator of a station calling CQ are copied to the *DX
|
||||
Call* and *DX Grid* entry fields.
|
||||
|
||||
** Messages are generated for a standard minimal QSO.
|
||||
|
||||
** The *Tx even* box is checked or cleared appropriately, so that you
|
||||
will transmit in the proper (odd or even) minutes.
|
||||
|
||||
** The Rx and Tx frequency markers are moved to the frequency of the
|
||||
CQing station.
|
||||
|
||||
** The *Gen Msg* ("`generated message`") radio button at bottom right
|
||||
of the main window is selected.
|
||||
|
||||
** If you had checked *Double-click on call sets Tx Enable* on the
|
||||
*Setup* menu, *Enable Tx* would be activated and a transmission would
|
||||
start automatically at the proper time.
|
||||
|
||||
- Double-click on the decoded message `K1JT N5KDV EM41`,
|
||||
highlighted in red. Results will be similar to those in the
|
||||
previous step, except the Tx frequency (red marker) is not
|
||||
moved. Such messages are usually in response to your own CQ, or from
|
||||
a tail-ender, and you probably want your Tx frequency to stay where it
|
||||
was.
|
||||
|
||||
- By holding down the *Ctrl* key when double-clicking on a decoded
|
||||
line you can cause both Tx and Rx frequencies to be moved. This
|
||||
behavior can also be forced by checking *Lock Tx=Rx*.
|
||||
|
||||
- Double-click on the message from KF4RWA in either window. He is
|
||||
sending `73` to K1JT, signifying that the QSO is over. Most likely
|
||||
you want to send 73 to him, so the message `KF4RWA K1JT 73` is
|
||||
automatically generated and selected for your next transmission.
|
||||
(Alternatively, you might choose to send a free-text message or to
|
||||
call CQ again.)
|
||||
|
||||
- Click somewhere on the waterfall to set Rx frequency (green marker
|
||||
on waterfall scale).
|
||||
|
||||
- Shift-click on the waterfall to set Tx frequency (red marker).
|
||||
|
||||
- Ctrl-click on the waterfall to set both Rx and Tx frequencies.
|
||||
|
||||
- Double-click on a signal in the waterfall to set Rx frequency and
|
||||
start a narrow-band decode there. Decoded text will appear in the
|
||||
right window only.
|
||||
|
||||
- Ctrl-double-click on a signal to set both Rx and Tx frequencies and
|
||||
decode at the new frequency.
|
||||
|
||||
- Click *Erase* to clear the right window.
|
||||
|
||||
- Double-click *Erase* to clear both text windows.
|
||||
@@ -0,0 +1,444 @@
|
||||
/*==============================================================================
|
||||
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)
|
||||
==============================================================================*/
|
||||
namespace detail {
|
||||
template <typename Object, typename MemPtr>
|
||||
struct mem_fun_ptr_gen
|
||||
{
|
||||
mem_fun_ptr_gen(Object const& obj_, MemPtr ptr_)
|
||||
: obj(obj_)
|
||||
, ptr(ptr_)
|
||||
{}
|
||||
typename phoenix::expression::mem_fun_ptr<Object, MemPtr>::type const
|
||||
operator()() const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<Object, MemPtr>::make(obj, ptr);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0
|
||||
>::type const
|
||||
operator()(A0 const& a0) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0
|
||||
>::make(obj, ptr, a0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1
|
||||
>::make(obj, ptr, a0 , a1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2
|
||||
>::make(obj, ptr, a0 , a1 , a2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16 , A17 const& a17) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9 , typename A10 , typename A11 , typename A12 , typename A13 , typename A14 , typename A15 , typename A16 , typename A17 , typename A18>
|
||||
typename phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18
|
||||
>::type const
|
||||
operator()(A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 , A15 const& a15 , A16 const& a16 , A17 const& a17 , A18 const& a18) const
|
||||
{
|
||||
return phoenix::expression::mem_fun_ptr<
|
||||
Object
|
||||
, MemPtr
|
||||
, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14 , A15 , A16 , A17 , A18
|
||||
>::make(obj, ptr, a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18);
|
||||
}
|
||||
Object const& obj;
|
||||
MemPtr ptr;
|
||||
};
|
||||
struct make_mem_fun_ptr_gen
|
||||
: proto::callable
|
||||
{
|
||||
template<typename Sig>
|
||||
struct result;
|
||||
template<typename This, typename Object, typename MemPtr>
|
||||
struct result<This(Object, MemPtr)>
|
||||
{
|
||||
typedef
|
||||
mem_fun_ptr_gen<
|
||||
typename remove_const<typename remove_reference<Object>::type>::type
|
||||
, typename remove_const<typename remove_reference<MemPtr>::type>::type
|
||||
>
|
||||
type;
|
||||
};
|
||||
template<typename Object, typename MemPtr>
|
||||
mem_fun_ptr_gen<Object, MemPtr> operator()(Object const & obj, MemPtr ptr) const
|
||||
{
|
||||
return mem_fun_ptr_gen<Object, MemPtr>(obj, ptr);
|
||||
}
|
||||
};
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 538 KiB |
@@ -0,0 +1,38 @@
|
||||
#ifndef GREG_DAY_OF_YEAR_HPP___
|
||||
#define GREG_DAY_OF_YEAR_HPP___
|
||||
|
||||
/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
|
||||
* Use, modification and distribution is subject to the
|
||||
* Boost Software License, Version 1.0. (See accompanying
|
||||
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
|
||||
* Author: Jeff Garland
|
||||
* $Date$
|
||||
*/
|
||||
|
||||
#include "boost/date_time/constrained_value.hpp"
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
namespace boost {
|
||||
namespace gregorian {
|
||||
|
||||
//! Exception type for day of year (1..366)
|
||||
struct bad_day_of_year : public std::out_of_range
|
||||
{
|
||||
bad_day_of_year() :
|
||||
std::out_of_range(std::string("Day of year value is out of range 1..366"))
|
||||
{}
|
||||
};
|
||||
|
||||
//! A day of the year range (1..366)
|
||||
typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;
|
||||
|
||||
//! Define a range representation type for the day of the year 1..366
|
||||
typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;
|
||||
|
||||
|
||||
} } //namespace gregorian
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,132 @@
|
||||
// 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 INHERITANCE_DWA200216_HPP
|
||||
# define INHERITANCE_DWA200216_HPP
|
||||
|
||||
# include <boost/python/type_id.hpp>
|
||||
# include <boost/shared_ptr.hpp>
|
||||
# include <boost/mpl/if.hpp>
|
||||
# include <boost/type_traits/is_polymorphic.hpp>
|
||||
# include <boost/type_traits/is_base_and_derived.hpp>
|
||||
# include <boost/detail/workaround.hpp>
|
||||
|
||||
namespace boost { namespace python { namespace objects {
|
||||
|
||||
typedef type_info class_id;
|
||||
using python::type_id;
|
||||
|
||||
// Types used to get address and id of most derived type
|
||||
typedef std::pair<void*,class_id> dynamic_id_t;
|
||||
typedef dynamic_id_t (*dynamic_id_function)(void*);
|
||||
|
||||
BOOST_PYTHON_DECL void register_dynamic_id_aux(
|
||||
class_id static_id, dynamic_id_function get_dynamic_id);
|
||||
|
||||
BOOST_PYTHON_DECL void add_cast(
|
||||
class_id src_t, class_id dst_t, void* (*cast)(void*), bool is_downcast);
|
||||
|
||||
//
|
||||
// a generator with an execute() function which, given a source type
|
||||
// and a pointer to an object of that type, returns its most-derived
|
||||
// /reachable/ type identifier and object pointer.
|
||||
//
|
||||
|
||||
// first, the case where T has virtual functions
|
||||
template <class T>
|
||||
struct polymorphic_id_generator
|
||||
{
|
||||
static dynamic_id_t execute(void* p_)
|
||||
{
|
||||
T* p = static_cast<T*>(p_);
|
||||
return std::make_pair(dynamic_cast<void*>(p), class_id(typeid(*p)));
|
||||
}
|
||||
};
|
||||
|
||||
// now, the non-polymorphic case.
|
||||
template <class T>
|
||||
struct non_polymorphic_id_generator
|
||||
{
|
||||
static dynamic_id_t execute(void* p_)
|
||||
{
|
||||
return std::make_pair(p_, python::type_id<T>());
|
||||
}
|
||||
};
|
||||
|
||||
// Now the generalized selector
|
||||
template <class T>
|
||||
struct dynamic_id_generator
|
||||
: mpl::if_<
|
||||
boost::is_polymorphic<T>
|
||||
, boost::python::objects::polymorphic_id_generator<T>
|
||||
, boost::python::objects::non_polymorphic_id_generator<T>
|
||||
>
|
||||
{};
|
||||
|
||||
// Register the dynamic id function for T with the type-conversion
|
||||
// system.
|
||||
template <class T>
|
||||
void register_dynamic_id(T* = 0)
|
||||
{
|
||||
typedef typename dynamic_id_generator<T>::type generator;
|
||||
register_dynamic_id_aux(
|
||||
python::type_id<T>(), &generator::execute);
|
||||
}
|
||||
|
||||
//
|
||||
// a generator with an execute() function which, given a void*
|
||||
// pointing to an object of type Source will attempt to convert it to
|
||||
// an object of type Target.
|
||||
//
|
||||
|
||||
template <class Source, class Target>
|
||||
struct dynamic_cast_generator
|
||||
{
|
||||
static void* execute(void* source)
|
||||
{
|
||||
return dynamic_cast<Target*>(
|
||||
static_cast<Source*>(source));
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template <class Source, class Target>
|
||||
struct implicit_cast_generator
|
||||
{
|
||||
static void* execute(void* source)
|
||||
{
|
||||
Target* result = static_cast<Source*>(source);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template <class Source, class Target>
|
||||
struct cast_generator
|
||||
: mpl::if_<
|
||||
is_base_and_derived<Target,Source>
|
||||
, implicit_cast_generator<Source,Target>
|
||||
, dynamic_cast_generator<Source,Target>
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
template <class Source, class Target>
|
||||
inline void register_conversion(
|
||||
bool is_downcast = ::boost::is_base_and_derived<Source,Target>::value
|
||||
// These parameters shouldn't be used; they're an MSVC bug workaround
|
||||
, Source* = 0, Target* = 0)
|
||||
{
|
||||
typedef typename cast_generator<Source,Target>::type generator;
|
||||
|
||||
add_cast(
|
||||
python::type_id<Source>()
|
||||
, python::type_id<Target>()
|
||||
, &generator::execute
|
||||
, is_downcast
|
||||
);
|
||||
}
|
||||
|
||||
}}} // namespace boost::python::object
|
||||
|
||||
#endif // INHERITANCE_DWA200216_HPP
|
||||
@@ -0,0 +1,296 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Olaf Krzikalla 2004-2006.
|
||||
// (C) Copyright Ion Gaztanaga 2006-2013
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org/libs/intrusive for documentation.
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_INTRUSIVE_SET_HOOK_HPP
|
||||
#define BOOST_INTRUSIVE_SET_HOOK_HPP
|
||||
|
||||
#include <boost/intrusive/detail/config_begin.hpp>
|
||||
#include <boost/intrusive/intrusive_fwd.hpp>
|
||||
|
||||
#include <boost/intrusive/detail/rbtree_node.hpp>
|
||||
#include <boost/intrusive/rbtree_algorithms.hpp>
|
||||
#include <boost/intrusive/options.hpp>
|
||||
#include <boost/intrusive/detail/generic_hook.hpp>
|
||||
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
namespace intrusive {
|
||||
|
||||
//! Helper metafunction to define a \c set_base_hook that yields to the same
|
||||
//! type when the same options (either explicitly or implicitly) are used.
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class ...Options>
|
||||
#else
|
||||
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>
|
||||
#endif
|
||||
struct make_set_base_hook
|
||||
{
|
||||
/// @cond
|
||||
typedef typename pack_options
|
||||
< hook_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
>::type packed_options;
|
||||
|
||||
typedef generic_hook
|
||||
< RbTreeAlgorithms
|
||||
, rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
|
||||
, typename packed_options::tag
|
||||
, packed_options::link_mode
|
||||
, RbTreeBaseHookId
|
||||
> implementation_defined;
|
||||
/// @endcond
|
||||
typedef implementation_defined type;
|
||||
};
|
||||
|
||||
//! Derive a class from set_base_hook in order to store objects in
|
||||
//! in a set/multiset. set_base_hook holds the data necessary to maintain
|
||||
//! the set/multiset and provides an appropriate value_traits class for set/multiset.
|
||||
//!
|
||||
//! The hook admits the following options: \c tag<>, \c void_pointer<>,
|
||||
//! \c link_mode<> and \c optimize_size<>.
|
||||
//!
|
||||
//! \c tag<> defines a tag to identify the node.
|
||||
//! The same tag value can be used in different classes, but if a class is
|
||||
//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its
|
||||
//! unique tag.
|
||||
//!
|
||||
//! \c void_pointer<> is the pointer type that will be used internally in the hook
|
||||
//! and the container configured to use this hook.
|
||||
//!
|
||||
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
|
||||
//! \c auto_unlink or \c safe_link).
|
||||
//!
|
||||
//! \c optimize_size<> will tell the hook to optimize the hook for size instead
|
||||
//! of speed.
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class ...Options>
|
||||
#else
|
||||
template<class O1, class O2, class O3, class O4>
|
||||
#endif
|
||||
class set_base_hook
|
||||
: public make_set_base_hook<
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
>::type
|
||||
{
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
public:
|
||||
//! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
|
||||
//! initializes the node to an unlinked state.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
set_base_hook();
|
||||
|
||||
//! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
|
||||
//! initializes the node to an unlinked state. The argument is ignored.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
//!
|
||||
//! <b>Rationale</b>: Providing a copy-constructor
|
||||
//! makes classes using the hook STL-compliant without forcing the
|
||||
//! user to do some additional work. \c swap can be used to emulate
|
||||
//! move-semantics.
|
||||
set_base_hook(const set_base_hook& );
|
||||
|
||||
//! <b>Effects</b>: Empty function. The argument is ignored.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
//!
|
||||
//! <b>Rationale</b>: Providing an assignment operator
|
||||
//! makes classes using the hook STL-compliant without forcing the
|
||||
//! user to do some additional work. \c swap can be used to emulate
|
||||
//! move-semantics.
|
||||
set_base_hook& operator=(const set_base_hook& );
|
||||
|
||||
//! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
|
||||
//! nothing (ie. no code is generated). If link_mode is \c safe_link and the
|
||||
//! object is stored in a set an assertion is raised. If link_mode is
|
||||
//! \c auto_unlink and \c is_linked() is true, the node is unlinked.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
~set_base_hook();
|
||||
|
||||
//! <b>Effects</b>: Swapping two nodes swaps the position of the elements
|
||||
//! related to those nodes in one or two containers. That is, if the node
|
||||
//! this is part of the element e1, the node x is part of the element e2
|
||||
//! and both elements are included in the containers s1 and s2, then after
|
||||
//! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
|
||||
//! at the position of e1. If one element is not in a container, then
|
||||
//! after the swap-operation the other element is not in a container.
|
||||
//! Iterators to e1 and e2 related to those nodes are invalidated.
|
||||
//!
|
||||
//! <b>Complexity</b>: Constant
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
void swap_nodes(set_base_hook &other);
|
||||
|
||||
//! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink.
|
||||
//!
|
||||
//! <b>Returns</b>: true, if the node belongs to a container, false
|
||||
//! otherwise. This function can be used to test whether \c set::iterator_to
|
||||
//! will return a valid iterator.
|
||||
//!
|
||||
//! <b>Complexity</b>: Constant
|
||||
bool is_linked() const;
|
||||
|
||||
//! <b>Effects</b>: Removes the node if it's inserted in a container.
|
||||
//! This function is only allowed if link_mode is \c auto_unlink.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
void unlink();
|
||||
#endif
|
||||
};
|
||||
|
||||
//! Helper metafunction to define a \c set_member_hook that yields to the same
|
||||
//! type when the same options (either explicitly or implicitly) are used.
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class ...Options>
|
||||
#else
|
||||
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>
|
||||
#endif
|
||||
struct make_set_member_hook
|
||||
{
|
||||
/// @cond
|
||||
typedef typename pack_options
|
||||
< hook_defaults,
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
>::type packed_options;
|
||||
|
||||
typedef generic_hook
|
||||
< RbTreeAlgorithms
|
||||
, rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
|
||||
, member_tag
|
||||
, packed_options::link_mode
|
||||
, NoBaseHookId
|
||||
> implementation_defined;
|
||||
/// @endcond
|
||||
typedef implementation_defined type;
|
||||
};
|
||||
|
||||
//! Put a public data member set_member_hook in order to store objects of this class in
|
||||
//! a set/multiset. set_member_hook holds the data necessary for maintaining the
|
||||
//! set/multiset and provides an appropriate value_traits class for set/multiset.
|
||||
//!
|
||||
//! The hook admits the following options: \c void_pointer<>,
|
||||
//! \c link_mode<> and \c optimize_size<>.
|
||||
//!
|
||||
//! \c void_pointer<> is the pointer type that will be used internally in the hook
|
||||
//! and the container configured to use this hook.
|
||||
//!
|
||||
//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
|
||||
//! \c auto_unlink or \c safe_link).
|
||||
//!
|
||||
//! \c optimize_size<> will tell the hook to optimize the hook for size instead
|
||||
//! of speed.
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED) || defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
template<class ...Options>
|
||||
#else
|
||||
template<class O1, class O2, class O3, class O4>
|
||||
#endif
|
||||
class set_member_hook
|
||||
: public make_set_member_hook<
|
||||
#if !defined(BOOST_INTRUSIVE_VARIADIC_TEMPLATES)
|
||||
O1, O2, O3, O4
|
||||
#else
|
||||
Options...
|
||||
#endif
|
||||
>::type
|
||||
{
|
||||
#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
|
||||
public:
|
||||
//! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
|
||||
//! initializes the node to an unlinked state.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
set_member_hook();
|
||||
|
||||
//! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
|
||||
//! initializes the node to an unlinked state. The argument is ignored.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
//!
|
||||
//! <b>Rationale</b>: Providing a copy-constructor
|
||||
//! makes classes using the hook STL-compliant without forcing the
|
||||
//! user to do some additional work. \c swap can be used to emulate
|
||||
//! move-semantics.
|
||||
set_member_hook(const set_member_hook& );
|
||||
|
||||
//! <b>Effects</b>: Empty function. The argument is ignored.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
//!
|
||||
//! <b>Rationale</b>: Providing an assignment operator
|
||||
//! makes classes using the hook STL-compliant without forcing the
|
||||
//! user to do some additional work. \c swap can be used to emulate
|
||||
//! move-semantics.
|
||||
set_member_hook& operator=(const set_member_hook& );
|
||||
|
||||
//! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
|
||||
//! nothing (ie. no code is generated). If link_mode is \c safe_link and the
|
||||
//! object is stored in a set an assertion is raised. If link_mode is
|
||||
//! \c auto_unlink and \c is_linked() is true, the node is unlinked.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
~set_member_hook();
|
||||
|
||||
//! <b>Effects</b>: Swapping two nodes swaps the position of the elements
|
||||
//! related to those nodes in one or two containers. That is, if the node
|
||||
//! this is part of the element e1, the node x is part of the element e2
|
||||
//! and both elements are included in the containers s1 and s2, then after
|
||||
//! the swap-operation e1 is in s2 at the position of e2 and e2 is in s1
|
||||
//! at the position of e1. If one element is not in a container, then
|
||||
//! after the swap-operation the other element is not in a container.
|
||||
//! Iterators to e1 and e2 related to those nodes are invalidated.
|
||||
//!
|
||||
//! <b>Complexity</b>: Constant
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
void swap_nodes(set_member_hook &other);
|
||||
|
||||
//! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink.
|
||||
//!
|
||||
//! <b>Returns</b>: true, if the node belongs to a container, false
|
||||
//! otherwise. This function can be used to test whether \c set::iterator_to
|
||||
//! will return a valid iterator.
|
||||
//!
|
||||
//! <b>Complexity</b>: Constant
|
||||
bool is_linked() const;
|
||||
|
||||
//! <b>Effects</b>: Removes the node if it's inserted in a container.
|
||||
//! This function is only allowed if link_mode is \c auto_unlink.
|
||||
//!
|
||||
//! <b>Throws</b>: Nothing.
|
||||
void unlink();
|
||||
#endif
|
||||
};
|
||||
|
||||
} //namespace intrusive
|
||||
} //namespace boost
|
||||
|
||||
#include <boost/intrusive/detail/config_end.hpp>
|
||||
|
||||
#endif //BOOST_INTRUSIVE_SET_HOOK_HPP
|
||||
@@ -0,0 +1,241 @@
|
||||
#include "displaytext.h"
|
||||
|
||||
#include <QMouseEvent>
|
||||
#include <QDateTime>
|
||||
#include <QTextCharFormat>
|
||||
#include <QTextCursor>
|
||||
#include <QTextBlock>
|
||||
#include <QMenu>
|
||||
#include <QAction>
|
||||
|
||||
#include "qt_helpers.hpp"
|
||||
|
||||
#include "moc_displaytext.cpp"
|
||||
|
||||
DisplayText::DisplayText(QWidget *parent)
|
||||
: QTextEdit(parent)
|
||||
, erase_action_ {new QAction {tr ("&Erase"), this}}
|
||||
{
|
||||
setReadOnly (true);
|
||||
viewport ()->setCursor (Qt::ArrowCursor);
|
||||
setWordWrapMode (QTextOption::NoWrap);
|
||||
|
||||
// max lines to limit heap usage
|
||||
document ()->setMaximumBlockCount (5000);
|
||||
|
||||
// context menu erase action
|
||||
setContextMenuPolicy (Qt::CustomContextMenu);
|
||||
connect (this, &DisplayText::customContextMenuRequested, [this] (QPoint const& position) {
|
||||
auto * menu = createStandardContextMenu (position);
|
||||
menu->addAction (erase_action_);
|
||||
menu->exec (mapToGlobal (position));
|
||||
delete menu;
|
||||
});
|
||||
connect (erase_action_, &QAction::triggered, this, &DisplayText::erase);
|
||||
}
|
||||
|
||||
void DisplayText::erase ()
|
||||
{
|
||||
clear ();
|
||||
Q_EMIT erased ();
|
||||
}
|
||||
|
||||
void DisplayText::setContentFont(QFont const& font)
|
||||
{
|
||||
char_font_ = font;
|
||||
selectAll ();
|
||||
auto cursor = textCursor ();
|
||||
cursor.beginEditBlock ();
|
||||
auto char_format = cursor.charFormat ();
|
||||
char_format.setFont (char_font_);
|
||||
cursor.mergeCharFormat (char_format);
|
||||
cursor.clearSelection ();
|
||||
cursor.movePosition (QTextCursor::End);
|
||||
|
||||
// position so viewport scrolled to left
|
||||
cursor.movePosition (QTextCursor::Up);
|
||||
cursor.movePosition (QTextCursor::StartOfLine);
|
||||
cursor.endEditBlock ();
|
||||
|
||||
setTextCursor (cursor);
|
||||
ensureCursorVisible ();
|
||||
}
|
||||
|
||||
void DisplayText::mouseDoubleClickEvent(QMouseEvent *e)
|
||||
{
|
||||
bool ctrl = (e->modifiers() & Qt::ControlModifier);
|
||||
bool alt = (e->modifiers() & Qt::AltModifier);
|
||||
emit(selectCallsign(alt,ctrl));
|
||||
QTextEdit::mouseDoubleClickEvent(e);
|
||||
}
|
||||
|
||||
void DisplayText::insertLineSpacer(QString const& line)
|
||||
{
|
||||
appendText (line, "#d3d3d3");
|
||||
}
|
||||
|
||||
void DisplayText::appendText(QString const& text, QColor bg)
|
||||
{
|
||||
auto cursor = textCursor ();
|
||||
cursor.movePosition (QTextCursor::End);
|
||||
auto block_format = cursor.blockFormat ();
|
||||
block_format.setBackground (bg);
|
||||
if (0 == cursor.position ())
|
||||
{
|
||||
cursor.setBlockFormat (block_format);
|
||||
auto char_format = cursor.charFormat ();
|
||||
char_format.setFont (char_font_);
|
||||
cursor.setCharFormat (char_format);
|
||||
}
|
||||
else
|
||||
{
|
||||
cursor.insertBlock (block_format);
|
||||
}
|
||||
cursor.insertText (text);
|
||||
|
||||
// position so viewport scrolled to left
|
||||
cursor.movePosition (QTextCursor::StartOfLine);
|
||||
setTextCursor (cursor);
|
||||
ensureCursorVisible ();
|
||||
document ()->setMaximumBlockCount (document ()->maximumBlockCount ());
|
||||
}
|
||||
|
||||
|
||||
QString DisplayText::appendDXCCWorkedB4(QString message, QString const& callsign, QColor * bg,
|
||||
LogBook const& logBook, QColor color_CQ,
|
||||
QColor color_DXCC,
|
||||
QColor color_NewCall)
|
||||
{
|
||||
// allow for seconds
|
||||
int padding {message.indexOf (" ") > 4 ? 2 : 0};
|
||||
QString call = callsign;
|
||||
QString countryName;
|
||||
bool callWorkedBefore;
|
||||
bool countryWorkedBefore;
|
||||
|
||||
if(call.length()==2) {
|
||||
int i0=message.indexOf("CQ "+call);
|
||||
call=message.mid(i0+6,-1);
|
||||
i0=call.indexOf(" ");
|
||||
call=call.mid(0,i0);
|
||||
}
|
||||
if(call.length()<3) return message;
|
||||
if(!call.contains(QRegExp("[0-9]|[A-Z]"))) return message;
|
||||
|
||||
logBook.match(/*in*/call,/*out*/countryName,callWorkedBefore,countryWorkedBefore);
|
||||
|
||||
message = message.trimmed ();
|
||||
QString appendage;
|
||||
if (!countryWorkedBefore) // therefore not worked call either
|
||||
{
|
||||
appendage += "!";
|
||||
*bg = color_DXCC;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!callWorkedBefore) // but have worked the country
|
||||
{
|
||||
appendage += "~";
|
||||
*bg = color_NewCall;
|
||||
}
|
||||
else
|
||||
{
|
||||
appendage += " "; // have worked this call before
|
||||
*bg = color_CQ;
|
||||
}
|
||||
}
|
||||
|
||||
// do some obvious abbreviations
|
||||
countryName.replace ("Islands", "Is.");
|
||||
countryName.replace ("Island", "Is.");
|
||||
countryName.replace ("North ", "N. ");
|
||||
countryName.replace ("Northern ", "N. ");
|
||||
countryName.replace ("South ", "S. ");
|
||||
countryName.replace ("East ", "E. ");
|
||||
countryName.replace ("Eastern ", "E. ");
|
||||
countryName.replace ("West ", "W. ");
|
||||
countryName.replace ("Western ", "W. ");
|
||||
countryName.replace ("Central ", "C. ");
|
||||
countryName.replace (" and ", " & ");
|
||||
countryName.replace ("Republic", "Rep.");
|
||||
countryName.replace ("United States", "U.S.A.");
|
||||
countryName.replace ("Fed. Rep. of ", "");
|
||||
countryName.replace ("French ", "Fr.");
|
||||
countryName.replace ("Asiatic", "AS");
|
||||
countryName.replace ("European", "EU");
|
||||
countryName.replace ("African", "AF");
|
||||
|
||||
appendage += countryName;
|
||||
|
||||
// use a nbsp to save the start of appended text so we can find
|
||||
// it again later, align appended data at a fixed column if
|
||||
// there is space otherwise let it float to the right
|
||||
int space_count {40 + padding - message.size ()};
|
||||
if (space_count > 0)
|
||||
{
|
||||
message += QString {space_count, QChar {' '}};
|
||||
}
|
||||
message += QChar::Nbsp + appendage;
|
||||
|
||||
return message;
|
||||
}
|
||||
|
||||
void DisplayText::displayDecodedText(DecodedText const& decodedText, QString const& myCall,
|
||||
bool displayDXCCEntity, LogBook const& logBook,
|
||||
QColor color_CQ, QColor color_MyCall,
|
||||
QColor color_DXCC, QColor color_NewCall)
|
||||
{
|
||||
QColor bg {Qt::white};
|
||||
bool CQcall = false;
|
||||
if (decodedText.string ().contains (" CQ ")
|
||||
|| decodedText.string ().contains (" CQDX ")
|
||||
|| decodedText.string ().contains (" QRZ "))
|
||||
{
|
||||
CQcall = true;
|
||||
bg = color_CQ;
|
||||
}
|
||||
if (myCall != "" and (
|
||||
decodedText.indexOf (" " + myCall + " ") >= 0
|
||||
or decodedText.indexOf (" " + myCall + "/") >= 0
|
||||
or decodedText.indexOf ("/" + myCall + " ") >= 0
|
||||
or decodedText.indexOf ("<" + myCall + " ") >= 0
|
||||
or decodedText.indexOf (" " + myCall + ">") >= 0)) {
|
||||
bg = color_MyCall;
|
||||
}
|
||||
auto message = decodedText.string ();
|
||||
message = message.left (message.indexOf (QChar::Nbsp)); // strip appended info
|
||||
if (displayDXCCEntity && CQcall)
|
||||
// if enabled add the DXCC entity and B4 status to the end of the
|
||||
// preformated text line t1
|
||||
message = appendDXCCWorkedB4 (message, decodedText.CQersCall (), &bg, logBook, color_CQ,
|
||||
color_DXCC, color_NewCall);
|
||||
appendText (message.trimmed (), bg);
|
||||
}
|
||||
|
||||
|
||||
void DisplayText::displayTransmittedText(QString text, QString modeTx, qint32 txFreq,
|
||||
QColor color_TxMsg, bool bFastMode)
|
||||
{
|
||||
QString t1=" @ ";
|
||||
if(modeTx=="FT8") t1=" ~ ";
|
||||
if(modeTx=="JT4") t1=" $ ";
|
||||
if(modeTx=="JT65") t1=" # ";
|
||||
if(modeTx=="MSK144") t1=" & ";
|
||||
QString t2;
|
||||
t2.sprintf("%4d",txFreq);
|
||||
QString t;
|
||||
if(bFastMode or modeTx=="FT8") {
|
||||
t = QDateTime::currentDateTimeUtc().toString("hhmmss") + \
|
||||
" Tx " + t2 + t1 + text;
|
||||
} else {
|
||||
t = QDateTime::currentDateTimeUtc().toString("hhmm") + \
|
||||
" Tx " + t2 + t1 + text;
|
||||
}
|
||||
appendText (t, color_TxMsg);
|
||||
}
|
||||
|
||||
void DisplayText::displayQSY(QString text)
|
||||
{
|
||||
QString t = QDateTime::currentDateTimeUtc().toString("hhmmss") + " " + text;
|
||||
appendText (t, "hotpink");
|
||||
}
|
||||
@@ -0,0 +1,175 @@
|
||||
|
||||
#ifndef BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED
|
||||
#define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2001-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$
|
||||
|
||||
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
|
||||
# include <boost/mpl/lambda_fwd.hpp>
|
||||
# include <boost/mpl/int.hpp>
|
||||
# include <boost/mpl/bool.hpp>
|
||||
# include <boost/mpl/aux_/na.hpp>
|
||||
# include <boost/mpl/aux_/arity.hpp>
|
||||
# include <boost/mpl/aux_/template_arity_fwd.hpp>
|
||||
#endif
|
||||
|
||||
#include <boost/mpl/aux_/preprocessor/params.hpp>
|
||||
#include <boost/mpl/aux_/preprocessor/enum.hpp>
|
||||
#include <boost/mpl/aux_/preprocessor/def_params_tail.hpp>
|
||||
#include <boost/mpl/aux_/lambda_arity_param.hpp>
|
||||
#include <boost/mpl/aux_/config/dtp.hpp>
|
||||
#include <boost/mpl/aux_/config/eti.hpp>
|
||||
#include <boost/mpl/aux_/nttp_decl.hpp>
|
||||
#include <boost/mpl/aux_/config/ttp.hpp>
|
||||
#include <boost/mpl/aux_/config/lambda.hpp>
|
||||
#include <boost/mpl/aux_/config/overload_resolution.hpp>
|
||||
|
||||
|
||||
#define BOOST_MPL_AUX_NA_PARAMS(i) \
|
||||
BOOST_MPL_PP_ENUM(i, na) \
|
||||
/**/
|
||||
|
||||
#if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES)
|
||||
# define BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \
|
||||
namespace aux { \
|
||||
template< BOOST_MPL_AUX_NTTP_DECL(int, N) > \
|
||||
struct arity< \
|
||||
name< BOOST_MPL_AUX_NA_PARAMS(i) > \
|
||||
, N \
|
||||
> \
|
||||
: int_< BOOST_MPL_LIMIT_METAFUNCTION_ARITY > \
|
||||
{ \
|
||||
}; \
|
||||
} \
|
||||
/**/
|
||||
#else
|
||||
# define BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) /**/
|
||||
#endif
|
||||
|
||||
#define BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \
|
||||
template<> \
|
||||
struct name< BOOST_MPL_AUX_NA_PARAMS(i) > \
|
||||
{ \
|
||||
template< \
|
||||
BOOST_MPL_PP_PARAMS(i, typename T) \
|
||||
BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) \
|
||||
> \
|
||||
struct apply \
|
||||
: name< BOOST_MPL_PP_PARAMS(i, T) > \
|
||||
{ \
|
||||
}; \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT)
|
||||
# define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \
|
||||
template<> \
|
||||
struct lambda< \
|
||||
name< BOOST_MPL_AUX_NA_PARAMS(i) > \
|
||||
, void_ \
|
||||
, true_ \
|
||||
> \
|
||||
{ \
|
||||
typedef false_ is_le; \
|
||||
typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \
|
||||
}; \
|
||||
template<> \
|
||||
struct lambda< \
|
||||
name< BOOST_MPL_AUX_NA_PARAMS(i) > \
|
||||
, void_ \
|
||||
, false_ \
|
||||
> \
|
||||
{ \
|
||||
typedef false_ is_le; \
|
||||
typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \
|
||||
}; \
|
||||
/**/
|
||||
#else
|
||||
# define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \
|
||||
template< typename Tag > \
|
||||
struct lambda< \
|
||||
name< BOOST_MPL_AUX_NA_PARAMS(i) > \
|
||||
, Tag \
|
||||
BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) \
|
||||
> \
|
||||
{ \
|
||||
typedef false_ is_le; \
|
||||
typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; \
|
||||
typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \
|
||||
}; \
|
||||
/**/
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \
|
||||
|| defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \
|
||||
&& defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION)
|
||||
# define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) \
|
||||
namespace aux { \
|
||||
template< BOOST_MPL_PP_PARAMS(j, typename T) > \
|
||||
struct template_arity< \
|
||||
name< BOOST_MPL_PP_PARAMS(j, T) > \
|
||||
> \
|
||||
: int_<j> \
|
||||
{ \
|
||||
}; \
|
||||
\
|
||||
template<> \
|
||||
struct template_arity< \
|
||||
name< BOOST_MPL_PP_ENUM(i, na) > \
|
||||
> \
|
||||
: int_<-1> \
|
||||
{ \
|
||||
}; \
|
||||
} \
|
||||
/**/
|
||||
#else
|
||||
# define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) /**/
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
|
||||
# define BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \
|
||||
template<> \
|
||||
struct name< BOOST_MPL_PP_ENUM(i, int) > \
|
||||
{ \
|
||||
typedef int type; \
|
||||
enum { value = 0 }; \
|
||||
}; \
|
||||
/**/
|
||||
#else
|
||||
# define BOOST_MPL_AUX_NA_SPEC_ETI(i, name) /**/
|
||||
#endif
|
||||
|
||||
#define BOOST_MPL_AUX_NA_PARAM(param) param = na
|
||||
|
||||
#define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name) \
|
||||
/**/
|
||||
|
||||
#define BOOST_MPL_AUX_NA_SPEC(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \
|
||||
/**/
|
||||
|
||||
#define BOOST_MPL_AUX_NA_SPEC2(i, j, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \
|
||||
BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) \
|
||||
/**/
|
||||
|
||||
|
||||
#endif // BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED
|
||||
@@ -0,0 +1,92 @@
|
||||
// config.hpp ---------------------------------------------------------------//
|
||||
|
||||
// Copyright 2012 Vicente J. Botet Escriba
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
|
||||
#ifndef BOOST_RATIO_CONFIG_HPP
|
||||
#define BOOST_RATIO_CONFIG_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
|
||||
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
|
||||
# if ! defined BOOST_NO_CXX11_U16STRING
|
||||
# define BOOST_NO_CXX11_U16STRING
|
||||
# endif
|
||||
# if ! defined BOOST_NO_CXX11_U32STRING
|
||||
# define BOOST_NO_CXX11_U32STRING
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined BOOST_RATIO_VERSION
|
||||
#define BOOST_RATIO_VERSION 1
|
||||
#else
|
||||
#if BOOST_RATIO_VERSION!=1 && BOOST_RATIO_VERSION!=2
|
||||
#error "BOOST_RATIO_VERSION must be 1 or 2"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if BOOST_RATIO_VERSION==1
|
||||
#if ! defined BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
|
||||
#define BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if BOOST_RATIO_VERSION==2
|
||||
#if ! defined BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
|
||||
#define BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef INTMAX_C
|
||||
#define BOOST_RATIO_INTMAX_C(a) INTMAX_C(a)
|
||||
#else
|
||||
#define BOOST_RATIO_INTMAX_C(a) a##LL
|
||||
#endif
|
||||
|
||||
#ifdef UINTMAX_C
|
||||
#define BOOST_RATIO_UINTMAX_C(a) UINTMAX_C(a)
|
||||
#else
|
||||
#define BOOST_RATIO_UINTMAX_C(a) a##ULL
|
||||
#endif
|
||||
|
||||
#define BOOST_RATIO_INTMAX_T_MAX (0x7FFFFFFFFFFFFFFELL)
|
||||
|
||||
|
||||
#ifndef BOOST_NO_CXX11_STATIC_ASSERT
|
||||
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
|
||||
#elif defined(BOOST_RATIO_USES_STATIC_ASSERT)
|
||||
#include <boost/static_assert.hpp>
|
||||
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
|
||||
#elif defined(BOOST_RATIO_USES_MPL_ASSERT)
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) \
|
||||
BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
|
||||
#else
|
||||
//~ #elif defined(BOOST_RATIO_USES_ARRAY_ASSERT)
|
||||
#define BOOST_RATIO_CONCAT(A,B) A##B
|
||||
#define BOOST_RATIO_NAME(A,B) BOOST_RATIO_CONCAT(A,B)
|
||||
#define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES) static char BOOST_RATIO_NAME(__boost_ratio_test_,__LINE__)[(CND)?1:-1]
|
||||
//~ #define BOOST_RATIO_STATIC_ASSERT(CND, MSG, TYPES)
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_RATIO_USES_MPL_ASSERT)
|
||||
#define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add"
|
||||
#define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub"
|
||||
#define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul"
|
||||
#define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div"
|
||||
#define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range"
|
||||
#define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0"
|
||||
#define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range"
|
||||
#endif
|
||||
|
||||
|
||||
//#define BOOST_RATIO_EXTENSIONS
|
||||
|
||||
#endif // header
|
||||
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/external/compute/compute.hpp
|
||||
|
||||
[begin_description]
|
||||
includes all headers required for using odeint with Boost.Compute
|
||||
[end_description]
|
||||
|
||||
Copyright 2009-2013 Karsten Ahnert
|
||||
Copyright 2009-2013 Mario Mulansky
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or
|
||||
copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
|
||||
#ifndef BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_HPP_DEFINED
|
||||
#define BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_HPP_DEFINED
|
||||
|
||||
#include <boost/numeric/odeint/external/compute/compute_algebra.hpp>
|
||||
#include <boost/numeric/odeint/external/compute/compute_operations.hpp>
|
||||
#include <boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp>
|
||||
#include <boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp>
|
||||
#include <boost/numeric/odeint/external/compute/compute_resize.hpp>
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_COMPUTE_COMPUTE_HPP_DEFINED
|
||||
Reference in New Issue
Block a user