chris/js8call
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial Commit

Browse Source
This commit is contained in:
Jordan Sherer
2018-02-08 21:28:33 -05:00
commit 678c1d3966
14352 changed files with 3176737 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.svn/pristine/a6/a606368edbcd12db999755db7d0fcafa435edb37.svn-base
+41
View File
@@ -0,0 +1,41 @@
/*=============================================================================
Copyright (c) 2011 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(BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED)
#define BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion
{
namespace result_of
{
template <typename Sequence, typename F>
struct for_each;
}
template <typename Sequence, typename F>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename
enable_if<
traits::is_sequence<Sequence>
, void
>::type
for_each(Sequence& seq, F const& f);
template <typename Sequence, typename F>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename
enable_if<
traits::is_sequence<Sequence>
, void
>::type
for_each(Sequence const& seq, F const& f);
}}
#endif
.svn/pristine/a6/a6083a5a6cbd3758f74342fbf71084ddcd11b91b.svn-base
+107
View File
@@ -0,0 +1,107 @@
/*=============================================================================
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2001-2003 Daniel Nuffer
http://spirit.sourceforge.net/
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef BOOST_SPIRIT_BASIC_CHSET_HPP
#define BOOST_SPIRIT_BASIC_CHSET_HPP
///////////////////////////////////////////////////////////////////////////////
#include <bitset>
#include <climits>
#include <boost/spirit/home/classic/utility/impl/chset/range_run.hpp>
#include <boost/spirit/home/classic/namespace.hpp>
namespace boost { namespace spirit {
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
///////////////////////////////////////////////////////////////////////////
//
// basic_chset: basic character set implementation using range_run
//
///////////////////////////////////////////////////////////////////////////
template <typename CharT>
class basic_chset
{
public:
basic_chset();
basic_chset(basic_chset const& arg_);
bool test(CharT v) const;
void set(CharT from, CharT to);
void set(CharT c);
void clear(CharT from, CharT to);
void clear(CharT c);
void clear();
void inverse();
void swap(basic_chset& x);
basic_chset& operator|=(basic_chset const& x);
basic_chset& operator&=(basic_chset const& x);
basic_chset& operator-=(basic_chset const& x);
basic_chset& operator^=(basic_chset const& x);
private: utility::impl::range_run<CharT> rr;
};
#if (CHAR_BIT == 8)
///////////////////////////////////////////////////////////////////////////
//
// basic_chset: specializations for 8 bit chars using std::bitset
//
///////////////////////////////////////////////////////////////////////////
template <typename CharT>
class basic_chset_8bit {
public:
basic_chset_8bit();
basic_chset_8bit(basic_chset_8bit const& arg_);
bool test(CharT v) const;
void set(CharT from, CharT to);
void set(CharT c);
void clear(CharT from, CharT to);
void clear(CharT c);
void clear();
void inverse();
void swap(basic_chset_8bit& x);
basic_chset_8bit& operator|=(basic_chset_8bit const& x);
basic_chset_8bit& operator&=(basic_chset_8bit const& x);
basic_chset_8bit& operator-=(basic_chset_8bit const& x);
basic_chset_8bit& operator^=(basic_chset_8bit const& x);
private: std::bitset<256> bset;
};
/////////////////////////////////
template <>
class basic_chset<char>
: public basic_chset_8bit<char> {};
/////////////////////////////////
template <>
class basic_chset<signed char>
: public basic_chset_8bit<signed char> {};
/////////////////////////////////
template <>
class basic_chset<unsigned char>
: public basic_chset_8bit<unsigned char> {};
#endif
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
}} // namespace BOOST_SPIRIT_CLASSIC_NS
#endif
#include <boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp>
.svn/pristine/a6/a60ac7a52555a02c79f8ef969f99f6049dac61b7.svn-base
+515
View File
@@ -0,0 +1,515 @@
// Copyright Peter Dimov 2001
// 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)
//
// Preprocessed version of "boost/mpl/bind.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
namespace aux {
template<
typename T, typename U1, typename U2, typename U3, typename U4
, typename U5
>
struct resolve_bind_arg
{
typedef T type;
};
template<
typename T
, typename Arg
>
struct replace_unnamed_arg
{
typedef Arg next;
typedef T type;
};
template<
typename Arg
>
struct replace_unnamed_arg< arg< -1 >, Arg >
{
typedef typename Arg::next next;
typedef Arg type;
};
template<
int N, typename U1, typename U2, typename U3, typename U4, typename U5
>
struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
{
typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
};
template<
typename F, typename T1, typename T2, typename T3, typename T4
, typename T5, typename U1, typename U2, typename U3, typename U4
, typename U5
>
struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
{
typedef bind< F,T1,T2,T3,T4,T5 > f_;
typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};
} // namespace aux
template<
typename F, int dummy_
>
struct bind0
{
template<
typename U1 = na, typename U2 = na, typename U3 = na
, typename U4 = na, typename U5 = na
>
struct apply
{
private:
typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
typedef typename r0::type a0;
typedef typename r0::next n1;
typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
///
public:
typedef typename apply_wrap0<
f_
>::type type;
};
};
namespace aux {
template<
typename F, typename U1, typename U2, typename U3, typename U4
, typename U5
>
struct resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
>
{
typedef bind0<F> f_;
typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};
} // namespace aux
BOOST_MPL_AUX_ARITY_SPEC(1, bind0)
BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0)
template<
typename F, int dummy_
>
struct bind< F,na,na,na,na,na >
: bind0<F>
{
};
template<
typename F, typename T1, int dummy_
>
struct bind1
{
template<
typename U1 = na, typename U2 = na, typename U3 = na
, typename U4 = na, typename U5 = na
>
struct apply
{
private:
typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
typedef typename r0::type a0;
typedef typename r0::next n1;
typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
///
typedef aux::replace_unnamed_arg< T1,n1 > r1;
typedef typename r1::type a1;
typedef typename r1::next n2;
typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
///
public:
typedef typename apply_wrap1<
f_
, typename t1::type
>::type type;
};
};
namespace aux {
template<
typename F, typename T1, typename U1, typename U2, typename U3
, typename U4, typename U5
>
struct resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
>
{
typedef bind1< F,T1 > f_;
typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};
} // namespace aux
BOOST_MPL_AUX_ARITY_SPEC(2, bind1)
BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1)
template<
typename F, typename T1, int dummy_
>
struct bind< F,T1,na,na,na,na >
: bind1< F,T1 >
{
};
template<
typename F, typename T1, typename T2, int dummy_
>
struct bind2
{
template<
typename U1 = na, typename U2 = na, typename U3 = na
, typename U4 = na, typename U5 = na
>
struct apply
{
private:
typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
typedef typename r0::type a0;
typedef typename r0::next n1;
typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
///
typedef aux::replace_unnamed_arg< T1,n1 > r1;
typedef typename r1::type a1;
typedef typename r1::next n2;
typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
///
typedef aux::replace_unnamed_arg< T2,n2 > r2;
typedef typename r2::type a2;
typedef typename r2::next n3;
typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
///
public:
typedef typename apply_wrap2<
f_
, typename t1::type, typename t2::type
>::type type;
};
};
namespace aux {
template<
typename F, typename T1, typename T2, typename U1, typename U2
, typename U3, typename U4, typename U5
>
struct resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
>
{
typedef bind2< F,T1,T2 > f_;
typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};
} // namespace aux
BOOST_MPL_AUX_ARITY_SPEC(3, bind2)
BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2)
template<
typename F, typename T1, typename T2, int dummy_
>
struct bind< F,T1,T2,na,na,na >
: bind2< F,T1,T2 >
{
};
template<
typename F, typename T1, typename T2, typename T3, int dummy_
>
struct bind3
{
template<
typename U1 = na, typename U2 = na, typename U3 = na
, typename U4 = na, typename U5 = na
>
struct apply
{
private:
typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
typedef typename r0::type a0;
typedef typename r0::next n1;
typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
///
typedef aux::replace_unnamed_arg< T1,n1 > r1;
typedef typename r1::type a1;
typedef typename r1::next n2;
typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
///
typedef aux::replace_unnamed_arg< T2,n2 > r2;
typedef typename r2::type a2;
typedef typename r2::next n3;
typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
///
typedef aux::replace_unnamed_arg< T3,n3 > r3;
typedef typename r3::type a3;
typedef typename r3::next n4;
typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
///
public:
typedef typename apply_wrap3<
f_
, typename t1::type, typename t2::type, typename t3::type
>::type type;
};
};
namespace aux {
template<
typename F, typename T1, typename T2, typename T3, typename U1
, typename U2, typename U3, typename U4, typename U5
>
struct resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
>
{
typedef bind3< F,T1,T2,T3 > f_;
typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};
} // namespace aux
BOOST_MPL_AUX_ARITY_SPEC(4, bind3)
BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3)
template<
typename F, typename T1, typename T2, typename T3, int dummy_
>
struct bind< F,T1,T2,T3,na,na >
: bind3< F,T1,T2,T3 >
{
};
template<
typename F, typename T1, typename T2, typename T3, typename T4
, int dummy_
>
struct bind4
{
template<
typename U1 = na, typename U2 = na, typename U3 = na
, typename U4 = na, typename U5 = na
>
struct apply
{
private:
typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
typedef typename r0::type a0;
typedef typename r0::next n1;
typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
///
typedef aux::replace_unnamed_arg< T1,n1 > r1;
typedef typename r1::type a1;
typedef typename r1::next n2;
typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
///
typedef aux::replace_unnamed_arg< T2,n2 > r2;
typedef typename r2::type a2;
typedef typename r2::next n3;
typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
///
typedef aux::replace_unnamed_arg< T3,n3 > r3;
typedef typename r3::type a3;
typedef typename r3::next n4;
typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
///
typedef aux::replace_unnamed_arg< T4,n4 > r4;
typedef typename r4::type a4;
typedef typename r4::next n5;
typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
///
public:
typedef typename apply_wrap4<
f_
, typename t1::type, typename t2::type, typename t3::type
, typename t4::type
>::type type;
};
};
namespace aux {
template<
typename F, typename T1, typename T2, typename T3, typename T4
, typename U1, typename U2, typename U3, typename U4, typename U5
>
struct resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
>
{
typedef bind4< F,T1,T2,T3,T4 > f_;
typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};
} // namespace aux
BOOST_MPL_AUX_ARITY_SPEC(5, bind4)
BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4)
template<
typename F, typename T1, typename T2, typename T3, typename T4
, int dummy_
>
struct bind< F,T1,T2,T3,T4,na >
: bind4< F,T1,T2,T3,T4 >
{
};
template<
typename F, typename T1, typename T2, typename T3, typename T4
, typename T5, int dummy_
>
struct bind5
{
template<
typename U1 = na, typename U2 = na, typename U3 = na
, typename U4 = na, typename U5 = na
>
struct apply
{
private:
typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
typedef typename r0::type a0;
typedef typename r0::next n1;
typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
///
typedef aux::replace_unnamed_arg< T1,n1 > r1;
typedef typename r1::type a1;
typedef typename r1::next n2;
typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
///
typedef aux::replace_unnamed_arg< T2,n2 > r2;
typedef typename r2::type a2;
typedef typename r2::next n3;
typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
///
typedef aux::replace_unnamed_arg< T3,n3 > r3;
typedef typename r3::type a3;
typedef typename r3::next n4;
typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
///
typedef aux::replace_unnamed_arg< T4,n4 > r4;
typedef typename r4::type a4;
typedef typename r4::next n5;
typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
///
typedef aux::replace_unnamed_arg< T5,n5 > r5;
typedef typename r5::type a5;
typedef typename r5::next n6;
typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;
///
public:
typedef typename apply_wrap5<
f_
, typename t1::type, typename t2::type, typename t3::type
, typename t4::type, typename t5::type
>::type type;
};
};
namespace aux {
template<
typename F, typename T1, typename T2, typename T3, typename T4
, typename T5, typename U1, typename U2, typename U3, typename U4
, typename U5
>
struct resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
>
{
typedef bind5< F,T1,T2,T3,T4,T5 > f_;
typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};
} // namespace aux
BOOST_MPL_AUX_ARITY_SPEC(6, bind5)
BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5)
/// primary template (not a specialization!)
template<
typename F, typename T1, typename T2, typename T3, typename T4
, typename T5, int dummy_
>
struct bind
: bind5< F,T1,T2,T3,T4,T5 >
{
};
/// if_/eval_if specializations
template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
struct quote3;
template< typename T1, typename T2, typename T3 > struct if_;
template<
typename Tag, typename T1, typename T2, typename T3
>
struct bind3<
quote3< if_,Tag >
, T1, T2, T3
>
{
template<
typename U1 = na, typename U2 = na, typename U3 = na
, typename U4 = na, typename U5 = na
>
struct apply
{
private:
typedef mpl::arg<1> n1;
typedef aux::replace_unnamed_arg< T1,n1 > r1;
typedef typename r1::type a1;
typedef typename r1::next n2;
typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
///
typedef aux::replace_unnamed_arg< T2,n2 > r2;
typedef typename r2::type a2;
typedef typename r2::next n3;
typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
///
typedef aux::replace_unnamed_arg< T3,n3 > r3;
typedef typename r3::type a3;
typedef typename r3::next n4;
typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
///
typedef typename if_<
typename t1::type
, t2, t3
>::type f_;
public:
typedef typename f_::type type;
};
};
}}
.svn/pristine/a6/a6202ad231194f1d9de36070a047d0044cf4f8e7.svn-base
+83
View File
@@ -0,0 +1,83 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_JOINT_VIEW_07162005_0140)
#define FUSION_JOINT_VIEW_07162005_0140
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/view/joint_view/joint_view_fwd.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/fusion/support/is_view.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/view/joint_view/joint_view_iterator.hpp>
#include <boost/fusion/view/joint_view/detail/begin_impl.hpp>
#include <boost/fusion/view/joint_view/detail/end_impl.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/inherit.hpp>
#include <boost/mpl/identity.hpp>
namespace boost { namespace fusion
{
struct joint_view_tag;
struct forward_traversal_tag;
struct fusion_sequence_tag;
template <typename Sequence1, typename Sequence2>
struct joint_view : sequence_base<joint_view<Sequence1, Sequence2> >
{
typedef joint_view_tag fusion_tag;
typedef fusion_sequence_tag tag; // this gets picked up by MPL
typedef typename
mpl::eval_if<
mpl::and_<
traits::is_associative<Sequence1>
, traits::is_associative<Sequence2>
>
, mpl::inherit2<forward_traversal_tag,associative_tag>
, mpl::identity<forward_traversal_tag>
>::type
category;
typedef mpl::true_ is_view;
typedef typename result_of::begin<Sequence1>::type first_type;
typedef typename result_of::end<Sequence1>::type last_type;
typedef typename result_of::begin<Sequence2>::type concat_type;
typedef typename result_of::end<Sequence2>::type concat_last_type;
typedef typename mpl::int_<
result_of::size<Sequence1>::value + result_of::size<Sequence2>::value>
size;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
joint_view(Sequence1& in_seq1, Sequence2& in_seq2)
: seq1(in_seq1)
, seq2(in_seq2)
{}
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
first_type first() const { return fusion::begin(seq1); }
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
concat_type concat() const { return fusion::begin(seq2); }
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
concat_last_type concat_last() const { return fusion::end(seq2); }
private:
// silence MSVC warning C4512: assignment operator could not be generated
joint_view& operator= (joint_view const&);
typename mpl::if_<traits::is_view<Sequence1>, Sequence1, Sequence1&>::type seq1;
typename mpl::if_<traits::is_view<Sequence2>, Sequence2, Sequence2&>::type seq2;
};
}}
#endif
.svn/pristine/a6/a621e1208237cac76ad9b1061998ee3205efd59e.svn-base
+25
View File
@@ -0,0 +1,25 @@
/*==============================================================================
Copyright (c) 2011 Hartmut Kaiser
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_PHOENIX_PREPROCESSED_CALL)
#define BOOST_PHOENIX_PREPROCESSED_CALL
#if BOOST_PHOENIX_LIMIT <= 10
#include <boost/phoenix/core/detail/cpp03/preprocessed/call_10.hpp>
#elif BOOST_PHOENIX_LIMIT <= 20
#include <boost/phoenix/core/detail/cpp03/preprocessed/call_20.hpp>
#elif BOOST_PHOENIX_LIMIT <= 30
#include <boost/phoenix/core/detail/cpp03/preprocessed/call_30.hpp>
#elif BOOST_PHOENIX_LIMIT <= 40
#include <boost/phoenix/core/detail/cpp03/preprocessed/call_40.hpp>
#elif BOOST_PHOENIX_LIMIT <= 50
#include <boost/phoenix/core/detail/cpp03/preprocessed/call_50.hpp>
#else
#error "BOOST_PHOENIX_LIMIT out of bounds for preprocessed headers"
#endif
#endif
.svn/pristine/a6/a6251ba3004c6daeb0afb1cca17f66458cec68f9.svn-base
+15
View File
@@ -0,0 +1,15 @@
/////////////////////////////////////////////////////////////////////////////
//
// (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.
//
/////////////////////////////////////////////////////////////////////////////
#if defined BOOST_MSVC
#pragma warning (pop)
#endif
.svn/pristine/a6/a629273eaaf9b466c3e65d2e5bda2a7d3e0da9cf.svn-base
+123
View File
@@ -0,0 +1,123 @@
////
Link file to hold all links
File Location: ./doc/common/links.adoc
Usage example: include::../common/links.adoc[]
Syntax: [link-id] [link] [displayed text]
Example:
:pskreporter: http://pskreporter.info/pskmap.html[PSK Reporter]
[link-id] = :pskreporter:
[link] http://pskreporter.info/pskmap.html
[displayed text] PSK Reporter
Perform searches from the doc root directory: doc
Search: grep -rl --exclude-dir="*\.svn" {pskreporter} .
grep -rl --exclude-dir="*\.svn" PSK Reporter .
grep -rl --exclude-dir="*\.svn" {devsvn} .
grep -rl --exclude-dir="*\.svn" {kvasd} .
grep -rl --exclude-dir="*\.svn" {ntpsetup} .
Include links.adoc: grep -rl --exclude-dir="*\.svn" pskreporter .
Exclude links.adoc: grep -rl --exclude-dir="*\.svn" {pskreporter} .
Note(s):
a). Don't forget a space then "." at the end.
b). To include links.adoc file itself, remove the brackets {} from
the pattern search:
c). Look at each of the files listed to ensure the [displayed text]
still makes sense in the caption. If not, just add another link. Be
aware of the translators requirements by trying to keep the displayed
text language agnostic or neutral e.g. use a proper noun like a
persons name or a document title in the language of the linked
document. Do not use plain English generic words for link text link
"here".
d). Edit lines as needed. Keeping them in alphabetic order help see dupes.
////
// General URL's
//:launchpadac6sl: https://launchpad.net/~jnogatch/+archive/wsjtx[WSJT-X Linux Packages]
:alarmejt: http://f5jmh.free.fr/index.php?page=english[AlarmeJT]
:asciidoc_cheatsheet: http://powerman.name/doc/asciidoc[AsciiDoc Cheatsheet]
:asciidoc_help: http://www.methods.co.nz/asciidoc/userguide.html[AsciiDoc User Guide]
:asciidoc_questions: http://www.methods.co.nz/asciidoc/faq.html[AsciiDoc FAQ]
:asciidoc_syntax: http://xpt.sourceforge.net/techdocs/nix/tool/asciidoc-syn/ascs01-AsciiDocMarkupSyntaxQuickSummary/single/[AsciiDoc Syntax]
:asciidoctor_style: http://asciidoctor.org/docs/asciidoc-writers-guide/#delimited-blocks[AsciiDoctor Styles Guide]
:asciidoctor_syntax: http://asciidoctor.org/docs/asciidoc-writers-guide/#delimited-blocks[AsciiDoctor Syntax Guide]
:cc_by_sa: http://creativecommons.org/licenses/by-sa/3.0/[Commons Attribution-ShareAlike 3.0 Unported License]
:debian32: http://physics.princeton.edu/pulsar/K1JT/wsjtx_{VERSION}_i386.deb[wsjtx_{VERSION}_i386.deb]
:debian64: http://physics.princeton.edu/pulsar/K1JT/wsjtx_{VERSION}_amd64.deb[wsjtx_{VERSION}_amd64.deb]
:raspbian: http://physics.princeton.edu/pulsar/K1JT/wsjtx_{VERSION}_armhf.deb[wsjtx_{VERSION}_armhf.deb]
:debian: http://www.debian.org/[Debian]
:dev_guide: http://www.physics.princeton.edu/pulsar/K1JT/wsjtx-doc/wsjt-dev-guide.html[Dev-Guide]
:devsvn1: http://sourceforge.net/p/wsjt/wsjt/HEAD/tree/[Devel-SVN]
:devsvn: http://sourceforge.net/p/wsjt/wsjt/HEAD/tree/[SourceForge]
:dimension4: http://www.thinkman.com/dimension4/[Thinking Man Software]
:download: http://physics.princeton.edu/pulsar/K1JT/wsjtx.html[Download Page]
:dxatlas: http://www.dxatlas.com/[Afreet Software, Inc.]
:dxlcommander: http://www.dxlabsuite.com/commander/[Commander]
:dxlsuite: http://www.dxlabsuite.com/[DX Lab Suite]
:fedora32: http://physics.princeton.edu/pulsar/K1JT/wsjtx-{VERSION}-i686.rpm[wsjtx-{VERSION}-i686.rpm]
:fedora64: http://physics.princeton.edu/pulsar/K1JT/wsjtx-{VERSION}-x86_64.rpm[wsjtx-{VERSION}-x86_64.rpm]
:fmt_arrl: http://www.arrl.org/frequency-measuring-test[ARRL FMT Info]
:fmt_group: https://groups.yahoo.com/neo/groups/FMT-nuts/info[FMT Group]
:fmt_k5cm: http://www.k5cm.com/[FMT Event Info]
:fmt_wspr: http://www.physics.princeton.edu/pulsar/K1JT/FMT_User.pdf[Accurate Frequency Measurements with your WSPR Setup]
:gnu_gpl: http://www.gnu.org/licenses/gpl-3.0.txt[GNU General Public License]
:homepage: http://physics.princeton.edu/pulsar/K1JT/[WSJT Home Page]
:hrd: http://www.hrdsoftwarellc.com/[Ham Radio Deluxe]
:jt4eme: http://physics.princeton.edu/pulsar/K1JT/WSJT-X_1.6.0_for_JT4_v7.pdf[Using WSJT-X for JT4 EME Operation]
:jt65protocol: http://physics.princeton.edu/pulsar/K1JT/JT65.pdf[QEX]
:jtalert: http://hamapps.com/[JT-Alert]
:launchpadki7mt: https://launchpad.net/~ki7mt[KI7MT PPA's]
:log4om: http://www.log4om.com[Log4OM]
:lunarEchoes: http://physics.princeton.edu/pulsar/K1JT/LunarEchoes_QEX.pdf[QEX]
:msys_url: http://sourceforge.net/projects/mingwbuilds/files/external-binary-packages/[MSYS Download]
:ntpsetup: http://www.satsignal.eu/ntp/setup.html[Network Time Protocol Setup]
:osx_instructions: http://physics.princeton.edu/pulsar/K1JT/OSX_Readme[Mac OS X Install Instructions]
:ppa: http://en.wikipedia.org/wiki/Personal_Package_Archive[PPA]
:projsummary: http://sourceforge.net/projects/wsjt/[Project Summary]
:pskreporter: http://pskreporter.info/pskmap.html[PSK Reporter]
:sourceforge: https://sourceforge.net/user/registration[SourceForge]
:sourceforge-jtsdk: https://sourceforge.net/projects/jtsdk[SourceForge JTSDK]
:ubuntu_sdk: https://launchpad.net/~ubuntu-sdk-team/+archive/ppa[Ubuntu SDK Notice]
:wsjt_yahoo_group: https://groups.yahoo.com/neo/groups/wsjtgroup/info[WSJT Group]
:wsjtx: http://physics.princeton.edu/pulsar/K1JT/wsjtx.html[WSJT-X]
:wspr0_guide: http://www.physics.princeton.edu/pulsar/K1JT/WSPR0_Instructions.TXT[WSPR0 Guide]
:wspr: http://physics.princeton.edu/pulsar/K1JT/wspr.html[WSPR Home Page]
:wsprnet: http://wsprnet.org/drupal/[WSPRnet]
:wsprnet_activity: http://wsprnet.org/drupal/wsprnet/activity[WSPRnet Activity page]
// Download Links
:cty_dat: http://www.country-files.com/cty/[Amateur Radio Country Files]
:jtbridge: http://jt-bridge.eller.nu/[JT-Bridge]
:jtsdk_doc: http://physics.princeton.edu/pulsar/K1JT/JTSDK-DOC.exe[Download]
:jtsdk_installer: http://sourceforge.net/projects/jtsdk/files/win32/2.0.0/JTSDK-2.0.0-B2-Win32.exe/download[Download]
:jtsdk_omnirig: http://sourceforge.net/projects/jtsdk/files/win32/2.0.0/base/contrib/OmniRig.zip/download[Download]
:jtsdk_py: http://physics.princeton.edu/pulsar/K1JT/JTSDK-PY.exe[Download]
:jtsdk_qt: http://physics.princeton.edu/pulsar/K1JT/JTSDK-QT.exe[Download]
:jtsdk_vcredist: http://sourceforge.net/projects/jtsdk/files/win32/2.0.0/base/contrib/vcredist_x86.exe/download[Download]
:nh6z: http://www.nh6z.net/Amatuer_Radio_Station_NH6Z/Other_Peoples_Software.html[here]
:omnirig: http://www.dxatlas.com/OmniRig/Files/OmniRig.zip[Download]
:osx: http://physics.princeton.edu/pulsar/K1JT/wsjtx-{VERSION}-Darwin.dmg[wsjtx-{VERSION}-Darwin.dmg]
:svn: http://subversion.apache.org/packages.html#windows[Subversion]
:win32: http://physics.princeton.edu/pulsar/K1JT/wsjtx-{VERSION}-win32.exe[wsjtx-{VERSION}-win32.exe]
:wsjt_svn: http://sourceforge.net/p/wsjt/wsjt/HEAD/tree/[WSJT Source Repository]
:wspr_code: http://physics.princeton.edu/pulsar/K1JT/WSPRcode.exe[WSPRcode.exe]
:wspr_svn: http://sourceforge.net/p/wsjt/wsjt/HEAD/tree/branches/wspr/[WSPR Source Repository]
// MAIL-TO links
:alex_efros: mailto:powerman@powerman.name[Alex Efros]
:bill_somerville: mailto:g4wjs -at- c l a s s d e s i g n -dot- com [G4WJS]
:dev_mail_list: http://sourceforge.net/mailarchive/forum.php?forum_name=wsjt-devel[WSJT Developers Email List]
:dev_mail_svn: https://sourceforge.net/auth/subscriptions/[WSJT SVN Archives]
:devmail: mailto:wsjt-devel@lists.sourceforge.net[wsjt-devel@lists.sourceforge.net]
:devmail1: mailto:wsjt-devel@lists.sourceforge.net[Post Message]
:wsjtgroup_mail: mailto:wsjtgroup@yahoogroups.com[Post Message]
:greg_beam: mailto:ki7mt@yahoo.com[KI7MT]
:joe_taylor: mailto:joe@princeton.edu[K1JT]
:stuart_rackman: mailto:srackham@gmail.com[Stuart Rackham]
.svn/pristine/a6/a62f8f10fb2b7df63719d6f2bd1e995a02f7f5e5.svn-base
+140
View File
@@ -0,0 +1,140 @@
/* Boost interval/rounded_transc.hpp template implementation file
*
* Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or
* copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP
#define BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP
#include <boost/numeric/interval/rounding.hpp>
#include <boost/numeric/interval/detail/bugs.hpp>
#include <boost/config/no_tr1/cmath.hpp>
namespace boost {
namespace numeric {
namespace interval_lib {
template<class T, class Rounding>
struct rounded_transc_exact: Rounding
{
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) { BOOST_NUMERIC_INTERVAL_using_math(f); return f(x); } \
T f##_up (const T& x) { BOOST_NUMERIC_INTERVAL_using_math(f); return f(x); }
BOOST_NUMERIC_INTERVAL_new_func(exp)
BOOST_NUMERIC_INTERVAL_new_func(log)
BOOST_NUMERIC_INTERVAL_new_func(sin)
BOOST_NUMERIC_INTERVAL_new_func(cos)
BOOST_NUMERIC_INTERVAL_new_func(tan)
BOOST_NUMERIC_INTERVAL_new_func(asin)
BOOST_NUMERIC_INTERVAL_new_func(acos)
BOOST_NUMERIC_INTERVAL_new_func(atan)
BOOST_NUMERIC_INTERVAL_new_func(sinh)
BOOST_NUMERIC_INTERVAL_new_func(cosh)
BOOST_NUMERIC_INTERVAL_new_func(tanh)
# undef BOOST_NUMERIC_INTERVAL_new_func
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) { BOOST_NUMERIC_INTERVAL_using_ahyp(f); return f(x); } \
T f##_up (const T& x) { BOOST_NUMERIC_INTERVAL_using_ahyp(f); return f(x); }
BOOST_NUMERIC_INTERVAL_new_func(asinh)
BOOST_NUMERIC_INTERVAL_new_func(acosh)
BOOST_NUMERIC_INTERVAL_new_func(atanh)
# undef BOOST_NUMERIC_INTERVAL_new_func
};
template<class T, class Rounding>
struct rounded_transc_std: Rounding
{
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_math(f); \
this->downward(); return this->force_rounding(f(x)); } \
T f##_up (const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_math(f); \
this->upward(); return this->force_rounding(f(x)); }
BOOST_NUMERIC_INTERVAL_new_func(exp)
BOOST_NUMERIC_INTERVAL_new_func(log)
BOOST_NUMERIC_INTERVAL_new_func(sin)
BOOST_NUMERIC_INTERVAL_new_func(cos)
BOOST_NUMERIC_INTERVAL_new_func(tan)
BOOST_NUMERIC_INTERVAL_new_func(asin)
BOOST_NUMERIC_INTERVAL_new_func(acos)
BOOST_NUMERIC_INTERVAL_new_func(atan)
BOOST_NUMERIC_INTERVAL_new_func(sinh)
BOOST_NUMERIC_INTERVAL_new_func(cosh)
BOOST_NUMERIC_INTERVAL_new_func(tanh)
# undef BOOST_NUMERIC_INTERVAL_new_func
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
this->downward(); return this->force_rounding(f(x)); } \
T f##_up (const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
this->upward(); return this->force_rounding(f(x)); }
BOOST_NUMERIC_INTERVAL_new_func(asinh)
BOOST_NUMERIC_INTERVAL_new_func(acosh)
BOOST_NUMERIC_INTERVAL_new_func(atanh)
# undef BOOST_NUMERIC_INTERVAL_new_func
};
template<class T, class Rounding>
struct rounded_transc_opp: Rounding
{
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_math(f); \
this->downward(); T y = this->force_rounding(f(x)); \
this->upward(); return y; } \
T f##_up (const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_math(f); \
return this->force_rounding(f(x)); }
BOOST_NUMERIC_INTERVAL_new_func(exp)
BOOST_NUMERIC_INTERVAL_new_func(log)
BOOST_NUMERIC_INTERVAL_new_func(cos)
BOOST_NUMERIC_INTERVAL_new_func(acos)
BOOST_NUMERIC_INTERVAL_new_func(cosh)
# undef BOOST_NUMERIC_INTERVAL_new_func
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_math(f); \
return -this->force_rounding(-f(x)); } \
T f##_up (const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_math(f); \
return this->force_rounding(f(x)); }
BOOST_NUMERIC_INTERVAL_new_func(sin)
BOOST_NUMERIC_INTERVAL_new_func(tan)
BOOST_NUMERIC_INTERVAL_new_func(asin)
BOOST_NUMERIC_INTERVAL_new_func(atan)
BOOST_NUMERIC_INTERVAL_new_func(sinh)
BOOST_NUMERIC_INTERVAL_new_func(tanh)
# undef BOOST_NUMERIC_INTERVAL_new_func
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
this->downward(); T y = this->force_rounding(f(x)); \
this->upward(); return y; } \
T f##_up (const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
return this->force_rounding(f(x)); }
BOOST_NUMERIC_INTERVAL_new_func(asinh)
BOOST_NUMERIC_INTERVAL_new_func(atanh)
# undef BOOST_NUMERIC_INTERVAL_new_func
# define BOOST_NUMERIC_INTERVAL_new_func(f) \
T f##_down(const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
return -this->force_rounding(-f(x)); } \
T f##_up (const T& x) \
{ BOOST_NUMERIC_INTERVAL_using_ahyp(f); \
return this->force_rounding(f(x)); }
BOOST_NUMERIC_INTERVAL_new_func(acosh)
# undef BOOST_NUMERIC_INTERVAL_new_func
};
} // namespace interval_lib
} // namespace numeric
} // namespace boost
#endif // BOOST_NUMERIC_INTERVAL_ROUNDED_TRANSC_HPP
.svn/pristine/a6/a6336f507e51d3045759e79619076aff8e0d9c51.svn-base
+170
View File
@@ -0,0 +1,170 @@
#ifndef DATE_TIME_FILETIME_FUNCTIONS_HPP__
#define DATE_TIME_FILETIME_FUNCTIONS_HPP__
/* Copyright (c) 2004 CrystalClear Software, Inc.
* Use, modification and distribution is subject to the
* Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
* Author: Jeff Garland, Bart Garst
* $Date$
*/
/*! @file filetime_functions.hpp
* Function(s) for converting between a FILETIME structure and a
* time object. This file is only available on systems that have
* BOOST_HAS_FTIME defined.
*/
#include <boost/date_time/compiler_config.hpp>
#if defined(BOOST_HAS_FTIME) // skip this file if no FILETIME
#if defined(BOOST_USE_WINDOWS_H)
# include <windows.h>
#endif
#include <boost/cstdint.hpp>
#include <boost/date_time/time.hpp>
#include <boost/date_time/date_defs.hpp>
namespace boost {
namespace date_time {
namespace winapi {
#if !defined(BOOST_USE_WINDOWS_H)
extern "C" {
struct FILETIME
{
boost::uint32_t dwLowDateTime;
boost::uint32_t dwHighDateTime;
};
struct SYSTEMTIME
{
boost::uint16_t wYear;
boost::uint16_t wMonth;
boost::uint16_t wDayOfWeek;
boost::uint16_t wDay;
boost::uint16_t wHour;
boost::uint16_t wMinute;
boost::uint16_t wSecond;
boost::uint16_t wMilliseconds;
};
__declspec(dllimport) void __stdcall GetSystemTimeAsFileTime(FILETIME* lpFileTime);
__declspec(dllimport) int __stdcall FileTimeToLocalFileTime(const FILETIME* lpFileTime, FILETIME* lpLocalFileTime);
__declspec(dllimport) void __stdcall GetSystemTime(SYSTEMTIME* lpSystemTime);
__declspec(dllimport) int __stdcall SystemTimeToFileTime(const SYSTEMTIME* lpSystemTime, FILETIME* lpFileTime);
} // extern "C"
#endif // defined(BOOST_USE_WINDOWS_H)
typedef FILETIME file_time;
typedef SYSTEMTIME system_time;
inline void get_system_time_as_file_time(file_time& ft)
{
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
// Some runtime library implementations expect local times as the norm for ctime.
file_time ft_utc;
GetSystemTimeAsFileTime(&ft_utc);
FileTimeToLocalFileTime(&ft_utc, &ft);
#elif defined(BOOST_HAS_GETSYSTEMTIMEASFILETIME)
GetSystemTimeAsFileTime(&ft);
#else
system_time st;
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ft);
#endif
}
/*!
* The function converts file_time into number of microseconds elapsed since 1970-Jan-01
*
* \note Only dates after 1970-Jan-01 are supported. Dates before will be wrapped.
*
* \note The function is templated on the FILETIME type, so that
* it can be used with both native FILETIME and the ad-hoc
* boost::date_time::winapi::file_time type.
*/
template< typename FileTimeT >
inline boost::uint64_t file_time_to_microseconds(FileTimeT const& ft)
{
/* shift is difference between 1970-Jan-01 & 1601-Jan-01
* in 100-nanosecond intervals */
const uint64_t shift = 116444736000000000ULL; // (27111902 << 32) + 3577643008
union {
FileTimeT as_file_time;
uint64_t as_integer; // 100-nanos since 1601-Jan-01
} caster;
caster.as_file_time = ft;
caster.as_integer -= shift; // filetime is now 100-nanos since 1970-Jan-01
return (caster.as_integer / 10); // truncate to microseconds
}
} // namespace winapi
//! Create a time object from an initialized FILETIME struct.
/*!
* Create a time object from an initialized FILETIME struct.
* A FILETIME struct holds 100-nanosecond units (0.0000001). When
* built with microsecond resolution the file_time's sub second value
* will be truncated. Nanosecond resolution has no truncation.
*
* \note The function is templated on the FILETIME type, so that
* it can be used with both native FILETIME and the ad-hoc
* boost::date_time::winapi::file_time type.
*/
template< typename TimeT, typename FileTimeT >
inline
TimeT time_from_ftime(const FileTimeT& ft)
{
typedef typename TimeT::date_type date_type;
typedef typename TimeT::date_duration_type date_duration_type;
typedef typename TimeT::time_duration_type time_duration_type;
// https://svn.boost.org/trac/boost/ticket/2523
// Since this function can be called with arbitrary times, including ones that
// are before 1970-Jan-01, we'll have to cast the time a bit differently,
// than it is done in the file_time_to_microseconds function. This allows to
// avoid integer wrapping for dates before 1970-Jan-01.
union {
FileTimeT as_file_time;
uint64_t as_integer; // 100-nanos since 1601-Jan-01
} caster;
caster.as_file_time = ft;
uint64_t sec = caster.as_integer / 10000000UL;
uint32_t sub_sec = (caster.as_integer % 10000000UL) // 100-nanoseconds since the last second
#if !defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
/ 10; // microseconds since the last second
#else
* 100; // nanoseconds since the last second
#endif
// split sec into usable chunks: days, hours, minutes, & seconds
const uint32_t sec_per_day = 86400; // seconds per day
uint32_t days = static_cast< uint32_t >(sec / sec_per_day);
uint32_t tmp = static_cast< uint32_t >(sec % sec_per_day);
uint32_t hours = tmp / 3600; // sec_per_hour
tmp %= 3600;
uint32_t minutes = tmp / 60; // sec_per_min
tmp %= 60;
uint32_t seconds = tmp; // seconds
date_duration_type dd(days);
date_type d = date_type(1601, Jan, 01) + dd;
return TimeT(d, time_duration_type(hours, minutes, seconds, sub_sec));
}
}} // boost::date_time
#endif // BOOST_HAS_FTIME
#endif // DATE_TIME_FILETIME_FUNCTIONS_HPP__
.svn/pristine/a6/a63418efed1ef8eaa61d1d088f2cf3624416e71f.svn-base
+67
View File
@@ -0,0 +1,67 @@
128
64
9
1 17 33 50 67 83 98 114 0
2 18 34 50 68 84 99 115 0
3 19 35 51 69 85 100 115 0
4 20 36 52 70 86 101 115 0
2 20 35 53 71 87 102 113 128
5 21 33 54 64 88 103 116 0
6 19 37 55 72 89 98 117 0
7 22 38 56 73 90 96 116 0
8 23 34 57 72 91 104 118 0
7 24 39 58 74 84 100 119 0
9 22 40 59 74 92 105 120 0
9 25 41 55 75 91 106 114 0
10 25 36 51 67 74 107 121 0
11 22 36 54 72 93 102 122 0
12 25 42 60 76 89 103 123 0
8 26 38 51 77 93 105 124 0
13 27 40 61 77 94 99 119 0
13 17 43 54 73 85 108 124 0
1 28 40 62 71 84 108 125 0
12 29 38 53 67 86 108 126 0
14 28 43 51 78 94 96 117 0
11 17 42 62 79 92 104 126 0
4 29 39 57 65 87 109 116 0
2 27 38 55 78 79 107 127 0
13 24 44 53 66 83 103 117 0
15 30 43 55 67 90 105 128 0
6 22 45 48 78 88 106 119 0
14 25 33 63 65 73 99 118 0
6 31 46 64 80 95 102 125 0
5 18 37 65 79 94 110 113 0
14 23 44 59 71 88 111 123 0
13 32 47 62 70 91 109 128 0
15 23 41 56 76 95 112 0 0
11 29 41 47 68 69 105 117 0
10 30 37 64 73 86 111 119 0
5 32 45 60 69 96 101 127 0
15 24 48 62 65 96 97 115 0
3 23 42 64 77 83 109 0 0
16 18 40 52 69 89 102 112 0
9 20 49 63 76 94 109 121 0
15 20 33 66 77 84 110 127 0
10 21 44 60 80 82 112 126 0
16 26 41 58 81 92 107 125 0
3 27 48 59 82 95 110 118 0
10 27 49 57 71 89 101 124 0
4 26 42 61 68 90 100 122 0
6 26 44 50 75 85 101 118 0
7 28 37 47 66 76 82 114 0
12 19 43 52 80 88 104 121 0
2 31 47 56 75 93 108 123 0
1 31 36 59 81 87 104 124 0
3 32 39 50 81 97 106 121 0
12 24 34 54 79 90 98 120 0
1 19 49 56 82 92 103 122 0
7 21 35 61 70 93 106 125 0
14 18 46 60 70 97 107 122 0
8 31 39 61 63 86 98 127 128
4 28 34 45 75 97 110 126 0
16 30 45 63 72 95 100 113 0
8 21 48 52 74 87 111 114 0
9 32 46 58 68 83 113 123 0
11 30 46 53 81 91 99 116 0
5 29 49 58 78 85 112 120 0
16 17 35 57 66 80 111 120 0
.svn/pristine/a6/a63a7164f7bf51275fbde3145f04ffdba177b819.svn-base
+121
View File
@@ -0,0 +1,121 @@
subroutine sfrsd(mrsym,mrprob,mr2sym,mr2prob,ntrials,correct,indexes, &
param,ntry)
integer mrsym(0:62),mrprob(0:62),mr2sym(0:62),mr2prob(0:62)
integer correct(0:62),indexes(0:62),probs(0:62),thresh0(0:62)
integer rxdat(0:62),rxdat2(0:62),rxprob(0:62),rxprob2(0:62)
integer workdat(0:62),era_pos(0:50)
integer perr(0:7,0:7)
integer param(0:7)
real ratio0(0:62)
call init_rs_int()
do i=0,62
rxdat(i)=mrsym(62-i)
rxdat2(i)=mr2sym(62-i)
rxprob(i)=mrprob(62-i)
rxprob2(i)=mr2prob(62-i)
enddo
do i=0,62
indexes(i)=i
probs(i)=rxprob(i)
enddo
do ip=1,62
do k=0,63-ip
if(probs(k).lt.probs(k+1)) then
ntmp=probs(k)
probs(k)=probs(k+1)
probs(k+1)=ntmp
ntmp=indexes(k)
indexes(k)=indexes(k+1)
indexes(k+1)=ntmp
endif
enddo
enddo
era_pos=0
numera=0
workdat=rxdat
call decode_rs_int()
if(nerr.ge.0) then
correct=workdat
param=0
return
endif
call random_seed()
ncandidates=0
nsum=0
do i=0,62
nsum=nsum+rxprob(i)
j=indexes(62-i)
ratio0(i)=float(rxprob2(j))/(float(rxprob(j))+0.01)
ii=int(7.999*ratio0(i))
jj=(62-i)/8
thresh0(i)=nint(1.3*perr(jj,ii))
enddo
if(nsum.eq.0) return
do k=0,ntrials
era_pos=0
workdat=rxdat
numera=0
do i=0,62
j=indexes(62-i)
thresh=thresh0(i)
ir=rand()
if(...) then
era_pos(numera)=j
numera=numera+1
endif
enddo
call decode_rs_int()
if(nerr.ge.0) then
ncandidates=ncandidates+1
nhard=0
nsoft=0
nsofter=0
do i=0,62
if(workdat(i).ne.rxdat(i)) then
nhard=nhard+1
nsofter=nsofter+rxprob(i)
if(workdat(i).ne.rxdat2(i)) nsoft=nsoft+rxprob(i)
else
nsofter=nsofter-rxprob(i)
endif
enddo
nsoft=63*nsoft/nsum
nsofter=63*nsofter/nsum
ntotal=nsoft+nhard
if(ntotal.lt.ntotal_min) then
nsoft_min=nsoft
nhard_min=nhard
nsofter_min=nsofter
ntotal_min=ntotal
correct=workdat
nera_best=numera
ntry=k
endif
if(ntotal_min.lt.72 .and. nhard_min.lt.42) exit
endif
if(k.eq.ntrials-1) ntry=k+1
enddo
if(ntotal_min.ge.76 .or. nhard.ge.44) nhard_min=-1
param(0)=ncandidates
param(1)=nhard_min
param(2)=nsoft_min
param(3)=nera_best
param(4)=nsofter_min
if(param(0).eq.0) param(2)=-1
return
end subroutine sfrsd
.svn/pristine/a6/a64a2c55341318e0013373b9d5f2a0722d7b0fa7.svn-base
+45
View File
@@ -0,0 +1,45 @@
///////////////////////////////////////////////////////////////////////////////
// expr1.hpp
// Contains definition of expr\<\>::operator() overloads.
//
// 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)
#define N BOOST_PP_ITERATION()
/// \overload
///
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
BOOST_FORCEINLINE
typename result_of::BOOST_PP_CAT(funop, N)<
expr const
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
>::type const
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
{
return result_of::BOOST_PP_CAT(funop, N)<
expr const
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
>::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
}
#ifdef BOOST_PROTO_DEFINE_TERMINAL
/// \overload
///
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
BOOST_FORCEINLINE
typename result_of::BOOST_PP_CAT(funop, N)<
expr
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
>::type const
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a))
{
return result_of::BOOST_PP_CAT(funop, N)<
expr
, default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
>::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
}
#endif
#undef N
.svn/pristine/a6/a64a4d0e3a8fdf90b2f58da57bab7cf07bacf5ae.svn-base
+40
View File
@@ -0,0 +1,40 @@
// Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006-2010.
// Copyright Antony Polukhin, 2011-2014.
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// enhanced with contributions from Terje Slettebo,
// with additional fixes and suggestions from Gennaro Prota,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
#ifndef BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
#define BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
# pragma once
#endif
namespace boost { namespace detail {
template <typename TargetChar, typename SourceChar>
struct widest_char {
typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
(sizeof(TargetChar) > sizeof(SourceChar))
, TargetChar
, SourceChar
>::type type;
};
}} // namespace boost::detail
#endif // BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
.svn/pristine/a6/a6526ad1ac2bc1fc2096f0bf548595e54ddb9796.svn-base
+126
View File
@@ -0,0 +1,126 @@
// (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).
//------------------------------------------------------------------------------
// no include guards, this file is guarded externally
#ifdef __WAVE__
// this file has been generated from the master.hpp file in the same directory
# pragma wave option(preserve: 0)
#endif
#if !defined(BOOST_FT_PREPROCESSING_MODE) || defined(BOOST_FT_CONFIG_HPP_INCLUDED)
# error "this file used with two-pass preprocessing, only"
#endif
#include <boost/preprocessor/slot/slot.hpp>
#include <boost/function_types/detail/encoding/def.hpp>
namespace boost { namespace function_types {
typedef detail::property_tag<BOOST_FT_non_variadic,BOOST_FT_variadic_mask> non_variadic;
typedef detail::property_tag<BOOST_FT_variadic,BOOST_FT_variadic_mask> variadic;
typedef detail::property_tag<0,BOOST_FT_const> non_const;
typedef detail::property_tag<BOOST_FT_const,BOOST_FT_const> const_qualified;
typedef detail::property_tag<0,BOOST_FT_volatile> non_volatile;
typedef detail::property_tag<BOOST_FT_volatile,BOOST_FT_volatile> volatile_qualified;
typedef detail::property_tag<BOOST_FT_default_cc,BOOST_FT_cc_mask> default_cc;
#define BOOST_PP_VALUE BOOST_FT_const|BOOST_FT_volatile
#include BOOST_PP_ASSIGN_SLOT(1)
typedef detail::property_tag<0 , BOOST_PP_SLOT(1)> non_cv;
typedef detail::property_tag<BOOST_FT_const , BOOST_PP_SLOT(1)> const_non_volatile;
typedef detail::property_tag<BOOST_FT_volatile, BOOST_PP_SLOT(1)> volatile_non_const;
typedef detail::property_tag<BOOST_PP_SLOT(1) , BOOST_PP_SLOT(1)> cv_qualified;
namespace detail {
typedef constant<BOOST_FT_full_mask> full_mask;
template <bits_t Flags, bits_t CCID> struct encode_bits_impl
{
BOOST_STATIC_CONSTANT( bits_t, value =
Flags | (BOOST_FT_default_cc * CCID) << 1 );
};
template <bits_t Flags, bits_t CCID, std::size_t Arity>
struct encode_charr_impl
{
BOOST_STATIC_CONSTANT(std::size_t, value = (std::size_t)(1+
Flags | (BOOST_FT_default_cc * CCID) << 1 | Arity << BOOST_FT_arity_shift
));
};
template <bits_t Bits> struct decode_bits
{
BOOST_STATIC_CONSTANT(bits_t, flags = Bits & BOOST_FT_flags_mask);
BOOST_STATIC_CONSTANT(bits_t, cc_id =
( (Bits & BOOST_FT_full_mask) / BOOST_FT_default_cc) >> 1
);
BOOST_STATIC_CONSTANT(bits_t, tag_bits = (Bits & BOOST_FT_full_mask));
BOOST_STATIC_CONSTANT(std::size_t, arity = (std::size_t)
(Bits >> BOOST_FT_arity_shift)
);
};
template <bits_t LHS_bits, bits_t LHS_mask, bits_t RHS_bits, bits_t RHS_mask>
struct tag_ice
{
BOOST_STATIC_CONSTANT(bool, match =
RHS_bits == (LHS_bits & RHS_mask & (RHS_bits |~BOOST_FT_type_mask))
);
BOOST_STATIC_CONSTANT(bits_t, combined_bits =
(LHS_bits & ~RHS_mask) | RHS_bits
);
BOOST_STATIC_CONSTANT(bits_t, combined_mask =
LHS_mask | RHS_mask
);
BOOST_STATIC_CONSTANT(bits_t, extracted_bits =
LHS_bits & RHS_mask
);
};
#define BOOST_FT_mask BOOST_FT_type_mask
typedef property_tag<BOOST_FT_callable_builtin,BOOST_FT_mask> callable_builtin_tag;
typedef property_tag<BOOST_FT_non_member_callable_builtin,BOOST_FT_mask> nonmember_callable_builtin_tag;
typedef property_tag<BOOST_FT_function,BOOST_FT_mask> function_tag;
typedef property_tag<BOOST_FT_reference,BOOST_FT_mask> reference_tag;
typedef property_tag<BOOST_FT_pointer,BOOST_FT_mask> pointer_tag;
typedef property_tag<BOOST_FT_member_function_pointer,BOOST_FT_mask> member_function_pointer_tag;
typedef property_tag<BOOST_FT_member_object_pointer,BOOST_FT_mask> member_object_pointer_tag;
typedef property_tag<BOOST_FT_member_object_pointer_flags,BOOST_FT_full_mask> member_object_pointer_base;
typedef property_tag<BOOST_FT_member_pointer,BOOST_FT_mask> member_pointer_tag;
#undef BOOST_FT_mask
#define BOOST_PP_VALUE BOOST_FT_function|BOOST_FT_non_variadic|BOOST_FT_default_cc
#include BOOST_PP_ASSIGN_SLOT(1)
#define BOOST_PP_VALUE BOOST_FT_type_mask|BOOST_FT_variadic_mask|BOOST_FT_cc_mask
#include BOOST_PP_ASSIGN_SLOT(2)
typedef property_tag< BOOST_PP_SLOT(1) , BOOST_PP_SLOT(2) > nv_dcc_func;
#define BOOST_PP_VALUE \
BOOST_FT_member_function_pointer|BOOST_FT_non_variadic|BOOST_FT_default_cc
#include BOOST_PP_ASSIGN_SLOT(1)
typedef property_tag< BOOST_PP_SLOT(1) , BOOST_PP_SLOT(2) > nv_dcc_mfp;
} // namespace detail
} } // namespace ::boost::function_types
.svn/pristine/a6/a65785635d3fe6b5bbe44fb10b21bf55633588ed.svn-base
+77
View File
@@ -0,0 +1,77 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_IS_SEQUENCE_05052005_1002)
#define FUSION_IS_SEQUENCE_05052005_1002
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct non_fusion_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct boost_array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename T>
struct is_sequence_impl
{
template <typename Sequence>
struct apply
: is_convertible<Sequence, fusion::detail::from_sequence_convertible_type>
{};
};
template <>
struct is_sequence_impl<non_fusion_tag>
{
template <typename T>
struct apply : mpl::false_ {};
};
template <>
struct is_sequence_impl<boost_tuple_tag>;
template <>
struct is_sequence_impl<boost_array_tag>;
template <>
struct is_sequence_impl<mpl_sequence_tag>;
template <>
struct is_sequence_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct is_sequence
: mpl::bool_<
(bool)extension::is_sequence_impl<
typename fusion::detail::tag_of<T>::type
>::template apply<T>::type::value
>
{};
template <typename Sequence, typename Enable = void>
struct is_native_fusion_sequence
: is_convertible<Sequence, fusion::detail::from_sequence_convertible_type>
{};
}
}}
#endif
.svn/pristine/a6/a65fc7722faf2757c620d9dfcf11a5231513794d.svn-base
+32
View File
@@ -0,0 +1,32 @@
#ifndef BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED
#define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/aux_/config/has_apply.hpp>
namespace boost { namespace mpl { namespace aux {
#if !defined(BOOST_MPL_CFG_NO_HAS_APPLY)
BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_apply, apply, false)
#else
template< typename T, typename fallback_ = false_ >
struct has_apply
: fallback_
{
};
#endif
}}}
#endif // BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED
.svn/pristine/a6/a6625045d56bcb88c293c4e9e0cbde4a69f046ee.svn-base
+34
View File
@@ -0,0 +1,34 @@
// 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_SI_DOSE_EQUIVALENT_HPP
#define BOOST_UNITS_SI_DOSE_EQUIVALENT_HPP
#include <boost/units/systems/si/base.hpp>
#include <boost/units/physical_dimensions/dose_equivalent.hpp>
namespace boost {
namespace units {
namespace si {
typedef unit<dose_equivalent_dimension,si::system> dose_equivalent;
BOOST_UNITS_STATIC_CONSTANT(sievert,dose_equivalent);
BOOST_UNITS_STATIC_CONSTANT(sieverts,dose_equivalent);
} // namespace si
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_SI_DOSE_EQUIVALENT_HPP
.svn/pristine/a6/a6650263a368b87433a7045e78811efada3e1976.svn-base
+12
View File
@@ -0,0 +1,12 @@
// Boost.Function library
// Copyright Douglas Gregor 2002-2003. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// For more information, see http://www.boost.org
#define BOOST_FUNCTION_NUM_ARGS 6
#include <boost/function/detail/maybe_include.hpp>
#undef BOOST_FUNCTION_NUM_ARGS
.svn/pristine/a6/a66626a71d8ef49abce423f3234f1e0679f8ee7e.svn-base
+29
View File
@@ -0,0 +1,29 @@
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002.
# * Distributed under the Boost Software License, Version 1.0. (See
# * accompanying file LICENSE_1_0.txt or copy at
# * http://www.boost.org/LICENSE_1_0.txt)
# * *
# ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_ARRAY_ELEM_HPP
# define BOOST_PREPROCESSOR_ARRAY_ELEM_HPP
#
# include <boost/preprocessor/array/data.hpp>
# include <boost/preprocessor/array/size.hpp>
# include <boost/preprocessor/config/config.hpp>
# include <boost/preprocessor/tuple/elem.hpp>
#
# /* BOOST_PP_ARRAY_ELEM */
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array))
# else
# define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_ARRAY_ELEM_I(i, array)
# define BOOST_PP_ARRAY_ELEM_I(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array))
# endif
#
# endif
.svn/pristine/a6/a66651525ec2ac3c39c967c45ffc24d107f62ebf.svn-base
+54
View File
@@ -0,0 +1,54 @@
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002.
# * Distributed under the Boost Software License, Version 1.0. (See
# * accompanying file LICENSE_1_0.txt or copy at
# * http://www.boost.org/LICENSE_1_0.txt)
# * *
# ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_ARRAY_REMOVE_HPP
# define BOOST_PREPROCESSOR_ARRAY_REMOVE_HPP
#
# include <boost/preprocessor/arithmetic/inc.hpp>
# include <boost/preprocessor/array/elem.hpp>
# include <boost/preprocessor/array/push_back.hpp>
# include <boost/preprocessor/array/size.hpp>
# include <boost/preprocessor/comparison/not_equal.hpp>
# include <boost/preprocessor/control/deduce_d.hpp>
# include <boost/preprocessor/control/iif.hpp>
# include <boost/preprocessor/control/while.hpp>
# include <boost/preprocessor/tuple/eat.hpp>
# include <boost/preprocessor/tuple/elem.hpp>
#
# /* BOOST_PP_ARRAY_REMOVE */
#
# define BOOST_PP_ARRAY_REMOVE(array, i) BOOST_PP_ARRAY_REMOVE_I(BOOST_PP_DEDUCE_D(), array, i)
# define BOOST_PP_ARRAY_REMOVE_I(d, array, i) BOOST_PP_ARRAY_REMOVE_D(d, array, i)
#
# /* BOOST_PP_ARRAY_REMOVE_D */
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
# define BOOST_PP_ARRAY_REMOVE_D(d, array, i) BOOST_PP_TUPLE_ELEM(4, 2, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_REMOVE_P, BOOST_PP_ARRAY_REMOVE_O, (0, i, (0, ()), array)))
# else
# define BOOST_PP_ARRAY_REMOVE_D(d, array, i) BOOST_PP_ARRAY_REMOVE_D_I(d, array, i)
# define BOOST_PP_ARRAY_REMOVE_D_I(d, array, i) BOOST_PP_TUPLE_ELEM(4, 2, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_REMOVE_P, BOOST_PP_ARRAY_REMOVE_O, (0, i, (0, ()), array)))
# endif
#
# define BOOST_PP_ARRAY_REMOVE_P(d, st) BOOST_PP_NOT_EQUAL(BOOST_PP_TUPLE_ELEM(4, 0, st), BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_ELEM(4, 3, st)))
#
# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT()
# define BOOST_PP_ARRAY_REMOVE_O(d, st) BOOST_PP_ARRAY_REMOVE_O_I st
# else
# define BOOST_PP_ARRAY_REMOVE_O(d, st) BOOST_PP_ARRAY_REMOVE_O_I(BOOST_PP_TUPLE_ELEM(4, 0, st), BOOST_PP_TUPLE_ELEM(4, 1, st), BOOST_PP_TUPLE_ELEM(4, 2, st), BOOST_PP_TUPLE_ELEM(4, 3, st))
# endif
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC()
# define BOOST_PP_ARRAY_REMOVE_O_I(n, i, res, arr) (BOOST_PP_INC(n), i, BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(n, i), BOOST_PP_ARRAY_PUSH_BACK, res BOOST_PP_TUPLE_EAT_2)(res, BOOST_PP_ARRAY_ELEM(n, arr)), arr)
# else
# define BOOST_PP_ARRAY_REMOVE_O_I(n, i, res, arr) (BOOST_PP_INC(n), i, BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(n, i), BOOST_PP_ARRAY_PUSH_BACK, BOOST_PP_TUPLE_ELEM_2_0)(res, BOOST_PP_ARRAY_ELEM(n, arr)), arr)
# endif
#
# endif
.svn/pristine/a6/a677cdb98c463192e2bb6ca19487f08f919dcdb4.svn-base
+92
View File
@@ -0,0 +1,92 @@
// boost thread_clock.cpp -----------------------------------------------------------//
// Copyright Beman Dawes 1994, 2006, 2008
// Copyright Vicente J. Botet Escriba 2009-2011
// Copyright Christopher Brown 2013
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
//--------------------------------------------------------------------------------------//
#include <boost/chrono/config.hpp>
#include <boost/chrono/thread_clock.hpp>
#include <cassert>
#include <boost/assert.hpp>
# include <pthread.h>
# include <mach/thread_act.h>
namespace boost { namespace chrono {
thread_clock::time_point thread_clock::now( ) BOOST_NOEXCEPT
{
// get the thread port (borrowing pthread's reference)
mach_port_t port = pthread_mach_thread_np(pthread_self());
// get the thread info
thread_basic_info_data_t info;
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
if ( thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count) != KERN_SUCCESS )
{
BOOST_ASSERT(0 && "Boost::Chrono - Internal Error");
return time_point();
}
// convert to nanoseconds
duration user = duration(
static_cast<thread_clock::rep>( info.user_time.seconds ) * 1000000000
+ static_cast<thread_clock::rep>(info.user_time.microseconds ) * 1000);
duration system = duration(
static_cast<thread_clock::rep>( info.system_time.seconds ) * 1000000000
+ static_cast<thread_clock::rep>( info.system_time.microseconds ) * 1000);
return time_point( user + system );
}
#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
thread_clock::time_point thread_clock::now( system::error_code & ec )
{
// get the thread port (borrowing pthread's reference)
mach_port_t port = pthread_mach_thread_np(pthread_self());
// get the thread info
thread_basic_info_data_t info;
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
if ( thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count) != KERN_SUCCESS )
{
if (BOOST_CHRONO_IS_THROWS(ec))
{
boost::throw_exception(
system::system_error(
EINVAL,
BOOST_CHRONO_SYSTEM_CATEGORY,
"chrono::thread_clock" ));
}
else
{
ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
return time_point();
}
}
if (!BOOST_CHRONO_IS_THROWS(ec))
{
ec.clear();
}
// convert to nanoseconds
duration user = duration(
static_cast<thread_clock::rep>( info.user_time.seconds ) * 1000000000
+ static_cast<thread_clock::rep>(info.user_time.microseconds ) * 1000);
duration system = duration(
static_cast<thread_clock::rep>( info.system_time.seconds ) * 1000000000
+ static_cast<thread_clock::rep>( info.system_time.microseconds ) * 1000);
return time_point( user + system );
}
#endif
} }
.svn/pristine/a6/a67d462a80b65d7596f07e77924d92868677692c.svn-base
+74
View File
@@ -0,0 +1,74 @@
// Copyright (c) 2015 John Maddock
// 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_ELLINT_JZ_HPP
#define BOOST_MATH_ELLINT_JZ_HPP
#ifdef _MSC_VER
#pragma once
#endif
#include <boost/math/special_functions/math_fwd.hpp>
#include <boost/math/special_functions/ellint_1.hpp>
#include <boost/math/special_functions/ellint_rj.hpp>
#include <boost/math/constants/constants.hpp>
#include <boost/math/policies/error_handling.hpp>
#include <boost/math/tools/workaround.hpp>
// Elliptic integral the Jacobi Zeta function.
namespace boost { namespace math {
namespace detail{
// Elliptic integral - Jacobi Zeta
template <typename T, typename Policy>
T jacobi_zeta_imp(T phi, T k, const Policy& pol)
{
BOOST_MATH_STD_USING
using namespace boost::math::tools;
using namespace boost::math::constants;
bool invert = false;
if(phi < 0)
{
phi = fabs(phi);
invert = true;
}
T result;
T sinp = sin(phi);
T cosp = cos(phi);
T s2 = sinp * sinp;
T k2 = k * k;
T kp = 1 - k2;
if(k == 1)
result = sinp * (boost::math::sign)(cosp); // We get here by simplifying JacobiZeta[w, 1] in Mathematica, and the fact that 0 <= phi.
else
result = k2 * sinp * cosp * sqrt(1 - k2 * s2) * ellint_rj_imp(T(0), kp, T(1), T(1 - k2 * s2), pol) / (3 * ellint_k_imp(k, pol));
return invert ? T(-result) : result;
}
} // detail
template <class T1, class T2, class Policy>
inline typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi, const Policy& pol)
{
typedef typename tools::promote_args<T1, T2>::type result_type;
typedef typename policies::evaluation<result_type, Policy>::type value_type;
return policies::checked_narrowing_cast<result_type, Policy>(detail::jacobi_zeta_imp(static_cast<value_type>(phi), static_cast<value_type>(k), pol), "boost::math::jacobi_zeta<%1%>(%1%,%1%)");
}
template <class T1, class T2>
inline typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi)
{
return boost::math::jacobi_zeta(k, phi, policies::policy<>());
}
}} // namespaces
#endif // BOOST_MATH_ELLINT_D_HPP
.svn/pristine/a6/a6836d44ce14c1d496c99e1f95c38d882c3bdf7f.svn-base
+50
View File
@@ -0,0 +1,50 @@
// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes,
// Howard Hinnant and John Maddock 2000.
// (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
// Fixed is_pointer, is_lvalue_reference, is_const, is_volatile, is_same,
// is_member_pointer based on the Simulated Partial Specialization work
// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or
// http://groups.yahoo.com/group/boost/message/5441
// Some workarounds in here use ideas suggested from "Generic<Programming>:
// Mappings between Types and Values"
// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html).
#ifndef BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
#if defined( __CODEGEARC__ )
template <class T> struct is_lvalue_reference : public integral_constant<bool, __is_reference(T)>{};
#else
template <class T> struct is_lvalue_reference : public false_type{};
template <class T> struct is_lvalue_reference<T&> : public true_type{};
#if defined(BOOST_ILLEGAL_CV_REFERENCES)
// these are illegal specialisations; cv-qualifies applied to
// references have no effect according to [8.3.2p1],
// C++ Builder requires them though as it treats cv-qualified
// references as distinct types...
template <class T> struct is_lvalue_reference<T&const> : public true_type{};
template <class T> struct is_lvalue_reference<T&volatile> : public true_type{};
template <class T> struct is_lvalue_reference<T&const volatile> : public true_type{};
#endif
#endif
} // namespace boost
#endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED
.svn/pristine/a6/a696a69c035601c64e9288e3747f6b4792e86f3f.svn-base
+91
View File
@@ -0,0 +1,91 @@
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_FUNCTIONAL_HASH_HPP
#define BOOST_COMPUTE_FUNCTIONAL_HASH_HPP
#include <boost/compute/function.hpp>
#include <boost/compute/types/fundamental.hpp>
namespace boost {
namespace compute {
namespace detail {
template<class Key>
std::string make_hash_function_name()
{
return std::string("boost_hash_") + type_name<Key>();
}
template<class Key>
inline std::string make_hash_function_source()
{
std::stringstream source;
source << "inline ulong " << make_hash_function_name<Key>()
<< "(const " << type_name<Key>() << " x)\n"
<< "{\n"
// note we reinterpret the argument as a 32-bit uint and
// then promote it to a 64-bit ulong for the result type
<< " ulong a = as_uint(x);\n"
<< " a = (a ^ 61) ^ (a >> 16);\n"
<< " a = a + (a << 3);\n"
<< " a = a ^ (a >> 4);\n"
<< " a = a * 0x27d4eb2d;\n"
<< " a = a ^ (a >> 15);\n"
<< " return a;\n"
<< "}\n";
return source.str();
}
template<class Key>
struct hash_impl
{
typedef Key argument_type;
typedef ulong_ result_type;
hash_impl()
: m_function("")
{
m_function = make_function_from_source<result_type(argument_type)>(
make_hash_function_name<argument_type>(),
make_hash_function_source<argument_type>()
);
}
template<class Arg>
invoked_function<result_type, boost::tuple<Arg> >
operator()(const Arg &arg) const
{
return m_function(arg);
}
function<result_type(argument_type)> m_function;
};
} // end detail namespace
/// The hash function returns a hash value for the input value.
///
/// The return type is \c ulong_ (the OpenCL unsigned long type).
template<class Key> struct hash;
/// \internal_
template<> struct hash<int_> : detail::hash_impl<int_> { };
/// \internal_
template<> struct hash<uint_> : detail::hash_impl<uint_> { };
/// \internal_
template<> struct hash<float_> : detail::hash_impl<float_> { };
} // end compute namespace
} // end boost namespace
#endif // BOOST_COMPUTE_FUNCTIONAL_HASH_HPP
.svn/pristine/a6/a6995e7d8910eafcc031a3b2c6257a258353d1ec.svn-base
+42
View File
@@ -0,0 +1,42 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP
#define BOOST_RANGE_REVERSE_ITERATOR_HPP
#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/iterator/reverse_iterator.hpp>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
template< typename T >
struct range_reverse_iterator
{
typedef reverse_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<T>::type>::type > type;
};
} // namespace boost
#endif
.svn/pristine/a6/a69c78be21161ed472fc1fc86accf73c82c70ce4.svn-base
+130
View File
@@ -0,0 +1,130 @@
#include "Radio.hpp"
#include <cmath>
#include <limits>
#include <QString>
#include <QChar>
#include <QRegularExpression>
namespace Radio
{
namespace
{
double constexpr MHz_factor {1.e6};
int constexpr frequency_precsion {6};
// very loose validation - callsign must contain a letter next to
// a number
QRegularExpression valid_callsign_regexp {R"(\d[[:alpha:]]|[[:alpha:]]\d)"};
}
Frequency frequency (QVariant const& v, int scale, bool * ok, QLocale const& locale)
{
double value {0.};
if (QVariant::String == v.type ())
{
value = locale.toDouble (v.value<QString> (), ok);
}
else
{
value = v.toDouble ();
if (ok) *ok = true;
}
value *= std::pow (10., scale);
if (ok)
{
if (value < 0. || value > std::numeric_limits<Frequency>::max ())
{
value = 0.;
*ok = false;
}
}
return std::llround (value);
}
FrequencyDelta frequency_delta (QVariant const& v, int scale, bool * ok, QLocale const& locale)
{
double value {0.};
if (QVariant::String == v.type ())
{
value = locale.toDouble (v.value<QString> (), ok);
}
else
{
value = v.toDouble ();
if (ok) *ok = true;
}
value *= std::pow (10., scale);
if (ok)
{
if (value < -std::numeric_limits<Frequency>::max ()
|| value > std::numeric_limits<Frequency>::max ())
{
value = 0.;
*ok = false;
}
}
return std::llround (value);
}
QString frequency_MHz_string (Frequency f, QLocale const& locale)
{
return locale.toString (f / MHz_factor, 'f', frequency_precsion);
}
QString frequency_MHz_string (FrequencyDelta d, QLocale const& locale)
{
return locale.toString (d / MHz_factor, 'f', frequency_precsion);
}
QString pretty_frequency_MHz_string (Frequency f, QLocale const& locale)
{
auto f_string = locale.toString (f / MHz_factor, 'f', frequency_precsion);
return f_string.insert (f_string.size () - 3, QChar::Nbsp);
}
QString pretty_frequency_MHz_string (double f, int scale, QLocale const& locale)
{
auto f_string = locale.toString (f / std::pow (10., scale - 6), 'f', frequency_precsion);
return f_string.insert (f_string.size () - 3, QChar::Nbsp);
}
QString pretty_frequency_MHz_string (FrequencyDelta d, QLocale const& locale)
{
auto d_string = locale.toString (d / MHz_factor, 'f', frequency_precsion);
return d_string.insert (d_string.size () - 3, QChar::Nbsp);
}
bool is_callsign (QString const& callsign)
{
return callsign.contains (valid_callsign_regexp);
}
bool is_compound_callsign (QString const& callsign)
{
return callsign.contains ('/');
}
// split on first '/' and return the larger portion or the whole if
// there is no '/'
QString base_callsign (QString callsign)
{
auto slash_pos = callsign.indexOf ('/');
if (slash_pos >= 0)
{
auto right_size = callsign.size () - slash_pos - 1;
if (right_size>= slash_pos)
{
callsign = callsign.mid (slash_pos + 1);
}
else
{
callsign = callsign.left (slash_pos);
}
}
return callsign;
}
}
.svn/pristine/a6/a6a51baeb7d2c1c83a84f71b5265429487ee83ee.svn-base
+55
View File
@@ -0,0 +1,55 @@
# /* **************************************************************************
# * *
# * (C) Copyright Edward Diener 2014.
# * Distributed under the Boost Software License, Version 1.0. (See
# * accompanying file LICENSE_1_0.txt or copy at
# * http://www.boost.org/LICENSE_1_0.txt)
# * *
# ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
#ifndef BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP
#define BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP
#include <boost/preprocessor/punctuation/is_begin_parens.hpp>
#if BOOST_PP_VARIADICS_MSVC
# pragma warning(once:4002)
#define BOOST_PP_DETAIL_IS_EMPTY_IIF_0(t, b) b
#define BOOST_PP_DETAIL_IS_EMPTY_IIF_1(t, b) t
#else
#define BOOST_PP_DETAIL_IS_EMPTY_IIF_0(t, ...) __VA_ARGS__
#define BOOST_PP_DETAIL_IS_EMPTY_IIF_1(t, ...) t
#endif
#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400
#define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(param) \
BOOST_PP_IS_BEGIN_PARENS \
( \
BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C param () \
) \
/**/
#else
#define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(...) \
BOOST_PP_IS_BEGIN_PARENS \
( \
BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ () \
) \
/**/
#endif
#define BOOST_PP_DETAIL_IS_EMPTY_PRIMITIVE_CAT(a, b) a ## b
#define BOOST_PP_DETAIL_IS_EMPTY_IIF(bit) BOOST_PP_DETAIL_IS_EMPTY_PRIMITIVE_CAT(BOOST_PP_DETAIL_IS_EMPTY_IIF_,bit)
#define BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C(...) ()
#endif /* BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP */
.svn/pristine/a6/a6b198482bc425969906813cea0d5b68dd20a4d4.svn-base
+463
View File
@@ -0,0 +1,463 @@
The following is the license under which the portions of the GNU C
library used in the rand.c module is distributed. Note that this
license does not apply to the rest of this software.
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of e Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
.svn/pristine/a6/a6b31141e9aef46a2fbd9ab984441044c3746768.svn-base
+103
View File
@@ -0,0 +1,103 @@
// (C) Copyright Gennadiy Rozental 2001.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org/libs/test for the library home page.
//
// File : $RCSfile$
//
// Version : $Revision: 74248 $
//
// Description : FPC tools tolerance holder
// ***************************************************************************
#ifndef BOOST_TEST_TOOLS_FPC_TOLERANCE_HPP_121612GER
#define BOOST_TEST_TOOLS_FPC_TOLERANCE_HPP_121612GER
// Boost Test
#include <boost/test/tree/decorator.hpp>
#include <boost/test/tools/floating_point_comparison.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace test_tools {
namespace fpc = math::fpc;
// ************************************************************************** //
// ************** floating point comparison tolerance ************** //
// ************************************************************************** //
template<typename FPT>
inline FPT&
fpc_tolerance()
{
static FPT s_value = 0;
return s_value;
}
//____________________________________________________________________________//
template<typename FPT>
struct local_fpc_tolerance {
local_fpc_tolerance( FPT fraction_tolerance ) : m_old_tolerance( fpc_tolerance<FPT>() )
{
fpc_tolerance<FPT>() = fraction_tolerance;
}
~local_fpc_tolerance()
{
if( m_old_tolerance != (FPT)-1 )
fpc_tolerance<FPT>() = m_old_tolerance;
}
private:
// Data members
FPT m_old_tolerance;
};
//____________________________________________________________________________//
} // namespace test_tools
// ************************************************************************** //
// ************** decorator::tolerance ************** //
// ************************************************************************** //
namespace unit_test {
namespace decorator {
template<typename FPT>
inline fixture_t
tolerance( FPT v )
{
return fixture_t( test_unit_fixture_ptr(
new unit_test::class_based_fixture<test_tools::local_fpc_tolerance<FPT>,FPT>( v ) ) );
}
//____________________________________________________________________________//
template<typename FPT>
inline fixture_t
tolerance( test_tools::fpc::percent_tolerance_t<FPT> v )
{
return fixture_t( test_unit_fixture_ptr(
new unit_test::class_based_fixture<test_tools::local_fpc_tolerance<FPT>,FPT>( boost::math::fpc::fpc_detail::fraction_tolerance<FPT>( v ) ) ) );
}
//____________________________________________________________________________//
} // namespace decorator
using decorator::tolerance;
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TOOLS_FPC_TOLERANCE_HPP_121612GER
.svn/pristine/a6/a6c951639eb81f76da0eedbc4162acf292c49d06.svn-base
+118
View File
@@ -0,0 +1,118 @@
#-------------------------------------------------
#
# 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 IARURegions.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 \
IARURegions.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)
}
.svn/pristine/a6/a6cd740af44d451e6185e662a5d42f3fe3df029b.svn-base
+410
View File
@@ -0,0 +1,410 @@
// Copyright Aleksey Gurtovoy 2000-2004
// Copyright David Abrahams 2003-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Preprocessed version of "boost/mpl/map/map40.hpp" header
// -- DO NOT modify by hand!
namespace boost { namespace mpl {
template<>
struct m_at_impl<30>
{
template< typename Map > struct result_
{
typedef typename Map::item30 type;
};
};
template<>
struct m_item_impl<31>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item30;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30
>
struct map31
: m_item<
31
, typename P30::first
, typename P30::second
, map30< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29 >
>
{
typedef map31 type;
};
template<>
struct m_at_impl<31>
{
template< typename Map > struct result_
{
typedef typename Map::item31 type;
};
};
template<>
struct m_item_impl<32>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item31;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31
>
struct map32
: m_item<
32
, typename P31::first
, typename P31::second
, map31< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30 >
>
{
typedef map32 type;
};
template<>
struct m_at_impl<32>
{
template< typename Map > struct result_
{
typedef typename Map::item32 type;
};
};
template<>
struct m_item_impl<33>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item32;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32
>
struct map33
: m_item<
33
, typename P32::first
, typename P32::second
, map32< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31 >
>
{
typedef map33 type;
};
template<>
struct m_at_impl<33>
{
template< typename Map > struct result_
{
typedef typename Map::item33 type;
};
};
template<>
struct m_item_impl<34>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item33;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32, typename P33
>
struct map34
: m_item<
34
, typename P33::first
, typename P33::second
, map33< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32 >
>
{
typedef map34 type;
};
template<>
struct m_at_impl<34>
{
template< typename Map > struct result_
{
typedef typename Map::item34 type;
};
};
template<>
struct m_item_impl<35>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item34;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32, typename P33, typename P34
>
struct map35
: m_item<
35
, typename P34::first
, typename P34::second
, map34< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33 >
>
{
typedef map35 type;
};
template<>
struct m_at_impl<35>
{
template< typename Map > struct result_
{
typedef typename Map::item35 type;
};
};
template<>
struct m_item_impl<36>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item35;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32, typename P33, typename P34
, typename P35
>
struct map36
: m_item<
36
, typename P35::first
, typename P35::second
, map35< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34 >
>
{
typedef map36 type;
};
template<>
struct m_at_impl<36>
{
template< typename Map > struct result_
{
typedef typename Map::item36 type;
};
};
template<>
struct m_item_impl<37>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item36;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32, typename P33, typename P34
, typename P35, typename P36
>
struct map37
: m_item<
37
, typename P36::first
, typename P36::second
, map36< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35 >
>
{
typedef map37 type;
};
template<>
struct m_at_impl<37>
{
template< typename Map > struct result_
{
typedef typename Map::item37 type;
};
};
template<>
struct m_item_impl<38>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item37;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32, typename P33, typename P34
, typename P35, typename P36, typename P37
>
struct map38
: m_item<
38
, typename P37::first
, typename P37::second
, map37< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36 >
>
{
typedef map38 type;
};
template<>
struct m_at_impl<38>
{
template< typename Map > struct result_
{
typedef typename Map::item38 type;
};
};
template<>
struct m_item_impl<39>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item38;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32, typename P33, typename P34
, typename P35, typename P36, typename P37, typename P38
>
struct map39
: m_item<
39
, typename P38::first
, typename P38::second
, map38< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37 >
>
{
typedef map39 type;
};
template<>
struct m_at_impl<39>
{
template< typename Map > struct result_
{
typedef typename Map::item39 type;
};
};
template<>
struct m_item_impl<40>
{
template< typename Key, typename T, typename Base > struct result_
: m_item_< Key,T,Base >
{
typedef pair< Key,T > item39;
};
};
template<
typename P0, typename P1, typename P2, typename P3, typename P4
, typename P5, typename P6, typename P7, typename P8, typename P9
, typename P10, typename P11, typename P12, typename P13, typename P14
, typename P15, typename P16, typename P17, typename P18, typename P19
, typename P20, typename P21, typename P22, typename P23, typename P24
, typename P25, typename P26, typename P27, typename P28, typename P29
, typename P30, typename P31, typename P32, typename P33, typename P34
, typename P35, typename P36, typename P37, typename P38, typename P39
>
struct map40
: m_item<
40
, typename P39::first
, typename P39::second
, map39< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38 >
>
{
typedef map40 type;
};
}}
.svn/pristine/a6/a6d3de6d9f198d5d5ec420bfe30f35f04c26aa06.svn-base
+25
View File
@@ -0,0 +1,25 @@
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2011. *
# * (C) Copyright Edward Diener 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. */
#
# ifndef BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP
# define BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP
#
# include <boost/preprocessor/cat.hpp>
# include <boost/preprocessor/variadic/size.hpp>
#
# /* BOOST_PP_OVERLOAD */
#
# if BOOST_PP_VARIADICS
# define BOOST_PP_OVERLOAD(prefix, ...) BOOST_PP_CAT(prefix, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__))
# endif
#
# endif
.svn/pristine/a6/a6e7b37eb5b703d1f84ae60438e93765583012fc.svn-base
+223
View File
@@ -0,0 +1,223 @@
// Copyright (c) 2007 John Maddock
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// This is a partial header, do not include on it's own!!!
//
// Contains asymptotic expansions for Bessel J(v,x) and Y(v,x)
// functions, as x -> INF.
//
#ifndef BOOST_MATH_SF_DETAIL_BESSEL_JY_ASYM_HPP
#define BOOST_MATH_SF_DETAIL_BESSEL_JY_ASYM_HPP
#ifdef _MSC_VER
#pragma once
#endif
#include <boost/math/special_functions/factorials.hpp>
namespace boost{ namespace math{ namespace detail{
template <class T>
inline T asymptotic_bessel_amplitude(T v, T x)
{
// Calculate the amplitude of J(v, x) and Y(v, x) for large
// x: see A&S 9.2.28.
BOOST_MATH_STD_USING
T s = 1;
T mu = 4 * v * v;
T txq = 2 * x;
txq *= txq;
s += (mu - 1) / (2 * txq);
s += 3 * (mu - 1) * (mu - 9) / (txq * txq * 8);
s += 15 * (mu - 1) * (mu - 9) * (mu - 25) / (txq * txq * txq * 8 * 6);
return sqrt(s * 2 / (constants::pi<T>() * x));
}
template <class T>
T asymptotic_bessel_phase_mx(T v, T x)
{
//
// Calculate the phase of J(v, x) and Y(v, x) for large x.
// See A&S 9.2.29.
// Note that the result returned is the phase less (x - PI(v/2 + 1/4))
// which we'll factor in later when we calculate the sines/cosines of the result:
//
T mu = 4 * v * v;
T denom = 4 * x;
T denom_mult = denom * denom;
T s = 0;
s += (mu - 1) / (2 * denom);
denom *= denom_mult;
s += (mu - 1) * (mu - 25) / (6 * denom);
denom *= denom_mult;
s += (mu - 1) * (mu * mu - 114 * mu + 1073) / (5 * denom);
denom *= denom_mult;
s += (mu - 1) * (5 * mu * mu * mu - 1535 * mu * mu + 54703 * mu - 375733) / (14 * denom);
return s;
}
template <class T>
inline T asymptotic_bessel_y_large_x_2(T v, T x)
{
// See A&S 9.2.19.
BOOST_MATH_STD_USING
// Get the phase and amplitude:
T ampl = asymptotic_bessel_amplitude(v, x);
T phase = asymptotic_bessel_phase_mx(v, x);
BOOST_MATH_INSTRUMENT_VARIABLE(ampl);
BOOST_MATH_INSTRUMENT_VARIABLE(phase);
//
// Calculate the sine of the phase, using
// sine/cosine addition rules to factor in
// the x - PI(v/2 + 1/4) term not added to the
// phase when we calculated it.
//
T cx = cos(x);
T sx = sin(x);
T ci = cos_pi(v / 2 + 0.25f);
T si = sin_pi(v / 2 + 0.25f);
T sin_phase = sin(phase) * (cx * ci + sx * si) + cos(phase) * (sx * ci - cx * si);
BOOST_MATH_INSTRUMENT_CODE(sin(phase));
BOOST_MATH_INSTRUMENT_CODE(cos(x));
BOOST_MATH_INSTRUMENT_CODE(cos(phase));
BOOST_MATH_INSTRUMENT_CODE(sin(x));
return sin_phase * ampl;
}
template <class T>
inline T asymptotic_bessel_j_large_x_2(T v, T x)
{
// See A&S 9.2.19.
BOOST_MATH_STD_USING
// Get the phase and amplitude:
T ampl = asymptotic_bessel_amplitude(v, x);
T phase = asymptotic_bessel_phase_mx(v, x);
BOOST_MATH_INSTRUMENT_VARIABLE(ampl);
BOOST_MATH_INSTRUMENT_VARIABLE(phase);
//
// Calculate the sine of the phase, using
// sine/cosine addition rules to factor in
// the x - PI(v/2 + 1/4) term not added to the
// phase when we calculated it.
//
BOOST_MATH_INSTRUMENT_CODE(cos(phase));
BOOST_MATH_INSTRUMENT_CODE(cos(x));
BOOST_MATH_INSTRUMENT_CODE(sin(phase));
BOOST_MATH_INSTRUMENT_CODE(sin(x));
T cx = cos(x);
T sx = sin(x);
T ci = cos_pi(v / 2 + 0.25f);
T si = sin_pi(v / 2 + 0.25f);
T sin_phase = cos(phase) * (cx * ci + sx * si) - sin(phase) * (sx * ci - cx * si);
BOOST_MATH_INSTRUMENT_VARIABLE(sin_phase);
return sin_phase * ampl;
}
template <class T>
inline bool asymptotic_bessel_large_x_limit(int v, const T& x)
{
BOOST_MATH_STD_USING
//
// Determines if x is large enough compared to v to take the asymptotic
// forms above. From A&S 9.2.28 we require:
// v < x * eps^1/8
// and from A&S 9.2.29 we require:
// v^12/10 < 1.5 * x * eps^1/10
// using the former seems to work OK in practice with broadly similar
// error rates either side of the divide for v < 10000.
// At double precision eps^1/8 ~= 0.01.
//
BOOST_ASSERT(v >= 0);
return (v ? v : 1) < x * 0.004f;
}
template <class T>
inline bool asymptotic_bessel_large_x_limit(const T& v, const T& x)
{
BOOST_MATH_STD_USING
//
// Determines if x is large enough compared to v to take the asymptotic
// forms above. From A&S 9.2.28 we require:
// v < x * eps^1/8
// and from A&S 9.2.29 we require:
// v^12/10 < 1.5 * x * eps^1/10
// using the former seems to work OK in practice with broadly similar
// error rates either side of the divide for v < 10000.
// At double precision eps^1/8 ~= 0.01.
//
return (std::max)(T(fabs(v)), T(1)) < x * sqrt(tools::forth_root_epsilon<T>());
}
template <class T, class Policy>
void temme_asyptotic_y_small_x(T v, T x, T* Y, T* Y1, const Policy& pol)
{
T c = 1;
T p = (v / boost::math::sin_pi(v, pol)) * pow(x / 2, -v) / boost::math::tgamma(1 - v, pol);
T q = (v / boost::math::sin_pi(v, pol)) * pow(x / 2, v) / boost::math::tgamma(1 + v, pol);
T f = (p - q) / v;
T g_prefix = boost::math::sin_pi(v / 2, pol);
g_prefix *= g_prefix * 2 / v;
T g = f + g_prefix * q;
T h = p;
T c_mult = -x * x / 4;
T y(c * g), y1(c * h);
for(int k = 1; k < policies::get_max_series_iterations<Policy>(); ++k)
{
f = (k * f + p + q) / (k*k - v*v);
p /= k - v;
q /= k + v;
c *= c_mult / k;
T c1 = pow(-x * x / 4, k) / factorial<T>(k, pol);
g = f + g_prefix * q;
h = -k * g + p;
y += c * g;
y1 += c * h;
if(c * g / tools::epsilon<T>() < y)
break;
}
*Y = -y;
*Y1 = (-2 / x) * y1;
}
template <class T, class Policy>
T asymptotic_bessel_i_large_x(T v, T x, const Policy& pol)
{
BOOST_MATH_STD_USING // ADL of std names
T s = 1;
T mu = 4 * v * v;
T ex = 8 * x;
T num = mu - 1;
T denom = ex;
s -= num / denom;
num *= mu - 9;
denom *= ex * 2;
s += num / denom;
num *= mu - 25;
denom *= ex * 3;
s -= num / denom;
// Try and avoid overflow to the last minute:
T e = exp(x/2);
s = e * (e * s / sqrt(2 * x * constants::pi<T>()));
return (boost::math::isfinite)(s) ?
s : policies::raise_overflow_error<T>("boost::math::asymptotic_bessel_i_large_x<%1%>(%1%,%1%)", 0, pol);
}
}}} // namespaces
#endif
.svn/pristine/a6/a6e938d80f7d590aa71905e2402a77f679bed11d.svn-base
+33
View File
@@ -0,0 +1,33 @@
/*==============================================================================
Copyright (c) 2005-2010 Joel de Guzman
Copyright (c) 2010 Thomas Heller
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PHOENIX_OPERATOR_LOGICAL_HPP
#define BOOST_PHOENIX_OPERATOR_LOGICAL_HPP
#include <boost/phoenix/operator/detail/define_operator.hpp>
#include <boost/phoenix/core/expression.hpp>
#include <boost/proto/operators.hpp>
namespace boost { namespace phoenix
{
BOOST_PHOENIX_UNARY_OPERATORS(
(logical_not)
)
BOOST_PHOENIX_BINARY_OPERATORS(
(logical_and)
(logical_or)
)
using proto::exprns_::operator!;
using proto::exprns_::operator&&;
using proto::exprns_::operator||;
}}
#include <boost/phoenix/operator/detail/undef_operator.hpp>
#endif