Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,50 @@
|
||||
parameter (NZ=339) !Total number of prefixes
|
||||
parameter (NZ2=12) !Total number of suffixes
|
||||
character*1 sfx(NZ2)
|
||||
character*5 pfx(NZ)
|
||||
|
||||
data sfx/'P','0','1','2','3','4','5','6','7','8','9','A'/
|
||||
data pfx/ &
|
||||
'1A ','1S ','3A ','3B6 ','3B8 ','3B9 ','3C ','3C0 ', &
|
||||
'3D2 ','3D2C ','3D2R ','3DA ','3V ','3W ','3X ','3Y ', &
|
||||
'3YB ','3YP ','4J ','4L ','4S ','4U1I ','4U1U ','4W ', &
|
||||
'4X ','5A ','5B ','5H ','5N ','5R ','5T ','5U ', &
|
||||
'5V ','5W ','5X ','5Z ','6W ','6Y ','7O ','7P ', &
|
||||
'7Q ','7X ','8P ','8Q ','8R ','9A ','9G ','9H ', &
|
||||
'9J ','9K ','9L ','9M2 ','9M6 ','9N ','9Q ','9U ', &
|
||||
'9V ','9X ','9Y ','A2 ','A3 ','A4 ','A5 ','A6 ', &
|
||||
'A7 ','A9 ','AP ','BS7 ','BV ','BV9 ','BY ','C2 ', &
|
||||
'C3 ','C5 ','C6 ','C9 ','CE ','CE0X ','CE0Y ','CE0Z ', &
|
||||
'CE9 ','CM ','CN ','CP ','CT ','CT3 ','CU ','CX ', &
|
||||
'CY0 ','CY9 ','D2 ','D4 ','D6 ','DL ','DU ','E3 ', &
|
||||
'E4 ','EA ','EA6 ','EA8 ','EA9 ','EI ','EK ','EL ', &
|
||||
'EP ','ER ','ES ','ET ','EU ','EX ','EY ','EZ ', &
|
||||
'F ','FG ','FH ','FJ ','FK ','FKC ','FM ','FO ', &
|
||||
'FOA ','FOC ','FOM ','FP ','FR ','FRG ','FRJ ','FRT ', &
|
||||
'FT5W ','FT5X ','FT5Z ','FW ','FY ','M ','MD ','MI ', &
|
||||
'MJ ','MM ', 'MU ','MW ','H4 ','H40 ','HA ', &
|
||||
'HB ','HB0 ','HC ','HC8 ','HH ','HI ','HK ','HK0 ', &
|
||||
'HK0M ','HL ','HM ','HP ','HR ','HS ','HV ','HZ ', &
|
||||
'I ','IS ','IS0 ', 'J2 ','J3 ','J5 ','J6 ', &
|
||||
'J7 ','J8 ','JA ','JDM ','JDO ','JT ','JW ', &
|
||||
'JX ','JY ','K ','KG4 ','KH0 ','KH1 ','KH2 ','KH3 ', &
|
||||
'KH4 ','KH5 ','KH5K ','KH6 ','KH7 ','KH8 ','KH9 ','KL ', &
|
||||
'KP1 ','KP2 ','KP4 ','KP5 ','LA ','LU ','LX ','LY ', &
|
||||
'LZ ','OA ','OD ','OE ','OH ','OH0 ','OJ0 ','OK ', &
|
||||
'OM ','ON ','OX ','OY ','OZ ','P2 ','P4 ','PA ', &
|
||||
'PJ2 ','PJ7 ','PY ','PY0F ','PT0S ','PY0T ','PZ ','R1F ', &
|
||||
'R1M ','S0 ','S2 ','S5 ','S7 ','S9 ','SM ','SP ', &
|
||||
'ST ','SU ','SV ','SVA ','SV5 ','SV9 ','T2 ','T30 ', &
|
||||
'T31 ','T32 ','T33 ','T5 ','T7 ','T8 ','T9 ','TA ', &
|
||||
'TF ','TG ','TI ','TI9 ','TJ ','TK ','TL ', &
|
||||
'TN ','TR ','TT ','TU ','TY ','TZ ','UA ','UA2 ', &
|
||||
'UA9 ','UK ','UN ','UR ','V2 ','V3 ','V4 ','V5 ', &
|
||||
'V6 ','V7 ','V8 ','VE ','VK ','VK0H ','VK0M ','VK9C ', &
|
||||
'VK9L ','VK9M ','VK9N ','VK9W ','VK9X ','VP2E ','VP2M ','VP2V ', &
|
||||
'VP5 ','VP6 ','VP6D ','VP8 ','VP8G ','VP8H ','VP8O ','VP8S ', &
|
||||
'VP9 ','VQ9 ','VR ','VU ','VU4 ','VU7 ','XE ','XF4 ', &
|
||||
'XT ','XU ','XW ','XX9 ','XZ ','YA ','YB ','YI ', &
|
||||
'YJ ','YK ','YL ','YN ','YO ','YS ','YU ','YV ', &
|
||||
'YV0 ','Z2 ','Z3 ','ZA ','ZB ','ZC4 ','ZD7 ','ZD8 ', &
|
||||
'ZD9 ','ZF ','ZK1N ','ZK1S ','ZK2 ','ZK3 ','ZL ','ZL7 ', &
|
||||
'ZL8 ','ZL9 ','ZP ','ZS ','ZS8 ','KC4 ','E5 '/
|
||||
@@ -0,0 +1,116 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
Copyright (c) 2006 Dan Marsden
|
||||
|
||||
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_PP_IS_ITERATING
|
||||
#if !defined(FUSION_PP_MAKE_DEQUE_07162005_0243)
|
||||
#define FUSION_MAKE_PP_DEQUE_07162005_0243
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/fusion/container/deque/deque.hpp>
|
||||
#include <boost/fusion/support/detail/as_fusion_element.hpp>
|
||||
|
||||
#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
|
||||
#include <boost/fusion/container/generation/detail/preprocessed/make_deque.hpp>
|
||||
#else
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
|
||||
#endif
|
||||
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct void_;
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <
|
||||
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
|
||||
FUSION_MAX_DEQUE_SIZE, typename T, void_)
|
||||
, typename Extra = void_
|
||||
>
|
||||
struct make_deque;
|
||||
|
||||
template <>
|
||||
struct make_deque<>
|
||||
{
|
||||
typedef deque<> type;
|
||||
};
|
||||
}
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<>
|
||||
make_deque()
|
||||
{
|
||||
return deque<>();
|
||||
}
|
||||
|
||||
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
|
||||
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
|
||||
|
||||
#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_deque.hpp>
|
||||
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#undef BOOST_FUSION_AS_FUSION_ELEMENT
|
||||
|
||||
}}
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
|
||||
|
||||
#endif
|
||||
#else // defined(BOOST_PP_IS_ITERATING)
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Preprocessor vertical repetition code
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
|
||||
#define TEXT(z, n, text) , text
|
||||
struct make_deque< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
|
||||
#undef TEXT
|
||||
{
|
||||
typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
|
||||
};
|
||||
}
|
||||
|
||||
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
|
||||
make_deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& arg))
|
||||
{
|
||||
return deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
|
||||
BOOST_PP_ENUM_PARAMS(N, arg));
|
||||
}
|
||||
|
||||
#undef N
|
||||
#endif // defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
@@ -0,0 +1,283 @@
|
||||
<HTML><HEAD>
|
||||
|
||||
<TITLE> Encoding Message Blocks </TITLE>
|
||||
|
||||
</HEAD><BODY>
|
||||
|
||||
|
||||
<H1> Encoding Message Blocks </H1>
|
||||
|
||||
To use a code to send messages, we must define a mapping from a bit
|
||||
vector, <B>s</B>, of length <I>K</I>, representing a source message,
|
||||
to a codeword, <B>x</B>, of length <I>N</I>><I>K</I>. We will
|
||||
consider only linear mappings, which can be written in the form
|
||||
<B>x</B>=<B>G</B><SUP><SMALL>T</SMALL></SUP><B>s</B>, where <B>G</B>
|
||||
is a <I>generator matrix</I>. For a code with parity check matrix
|
||||
<B>H</B>, whose codewords satisfy <B>Hx</B>=<B>0</B>, the generator
|
||||
matrix must satisfy <B>HG</B><SUP><SMALL>T</SMALL></SUP>=<B>0</B>.
|
||||
This software assumes that the number of rows in the parity check
|
||||
matrix, <I>M</I>, is equal to <I>N-K</I>, as would normally be the
|
||||
case.
|
||||
|
||||
<P>This software deals only with <I>systematic</I> encodings, in which
|
||||
the <I>K</I> bits of <B>s</B> are copied unchanged to some subset of
|
||||
the <I>N</i> bits of <B>x</B> (the <I>message bits</I>), and the
|
||||
remaining <I>M=N-K</I> <I>check bits</I> of <B>x</B> are then set so
|
||||
as to make the result a codeword. For a linear code, a systematic
|
||||
encoding scheme always exists, for some choice of which bits of a
|
||||
codeword are message bits. It is conventional to rearrange the order
|
||||
of the bits in a codeword so that the message bits come first. The
|
||||
first <I>K</I> columns of the <I>K</I> by <I>N</I> generator matrix
|
||||
will then be the identity matrix.
|
||||
|
||||
<P>However, this software does <I>not</I> assume that the message bits
|
||||
come first, since different encoding methods prefer different
|
||||
locations for the message bits. Instead, a vector of indexes of where
|
||||
each message bit is located within a codeword is recorded in a file
|
||||
along with a representation of the part of the generator matrix that
|
||||
produces the check bits. More than one such generator matrix file can
|
||||
be created for a single parity check file, in which the locations of
|
||||
the message bits may be different. Decoding of a received message
|
||||
into a codeword (with <A
|
||||
HREF="decoding.html#decode"><TT>decode</TT></A>) does not depend on
|
||||
knowing which are the message bits, though this does need to be known
|
||||
in order to reconstruct the original message (with <A
|
||||
HREF="decoding.html#extract"><TT>extract</TT></A>).
|
||||
|
||||
<P>This software stores representations of generator matrices in files
|
||||
in a format that is not human-readable (except by using the <A
|
||||
HREF="#print-gen"><TT>print-gen</TT></A> program). However, these
|
||||
files <I>are</I> readable on a machine with a different architecture
|
||||
than they were written on.
|
||||
|
||||
|
||||
<A NAME="gen-rep"><H2>Generator matrix representations</H2></A>
|
||||
|
||||
<P>For simplicity of exposition, it will be assumed for the next few
|
||||
paragraphs that the message bits are located at the <I>end</I> of the
|
||||
codeword, so a codeword can be divided into <I>M</I> check bits,
|
||||
<B>c</B>, followed by <I>K</I> message bits, <B>s</B>.
|
||||
|
||||
<P>On the above assumption, the parity check matrix, <B>H</B>, can be divided
|
||||
into an <I>M</I> by <I>M</I> matrix <B>A</B> occupying
|
||||
the first <I>M</I> columns of <B>H</B> and an <I>M</I> by <I>K</I> matrix
|
||||
<B>B</B> occupying the remaining columns of <B>H</B>. The requirement that
|
||||
a codeword, <B>x</B>, satisfy all parity checks (ie, that <B>Hx</B>=<B>0</B>)
|
||||
can then be written as
|
||||
<BLOCKQUOTE>
|
||||
<B>Ac</B> + <B>Bs</B> = <B>0</B>
|
||||
</BLOCKQUOTE>
|
||||
Provided that <B>A</B> is non-singular, it follows that
|
||||
<BLOCKQUOTE>
|
||||
<B>c</B> = <B>A</B><SUP><SMALL>-1</SMALL></SUP><B>Bs</B>
|
||||
</BLOCKQUOTE>
|
||||
<B>A</B> may be singular for some choices of which codeword bits are message
|
||||
bits, but a choice for which <B>A</B> is non-singular always exists if the
|
||||
rows of <B>H</B> are linearly independent. It is possible, however, that the
|
||||
rows of <B>H</B> are not linearly independent (ie, some rows are redundant).
|
||||
This is an exceptional
|
||||
and not particularly interesting case, which is mostly ignored in the
|
||||
descriptions below; see the discussion of <A HREF="dep-H.html">linear
|
||||
dependence in parity check matrices</A> for the details.
|
||||
|
||||
<P>The equation <B>c</B> = <B>A</B><SUP><SMALL>-1</SMALL></SUP><B>Bs</B>
|
||||
defines what the check bits should be, but actual computation of these
|
||||
check bits can be done in several ways, three of which are implemented
|
||||
in this software. Each method involves a different representation of
|
||||
the generator matrix. (Note that none of these methods involves the
|
||||
explicit representation of the matrix <B>G</B> mentioned above.)
|
||||
|
||||
<P>In the <I>dense representation</I>, the <I>M</I> by <I>K</I> matrix
|
||||
<B>A</B><SUP><SMALL>-1</SMALL></SUP><B>B</B> is computed, and stored
|
||||
in a dense format (see the <A HREF="mod2dense.html">dense modulo-2
|
||||
matrix package</A>). A message is encoded by multiplying the
|
||||
source bits, <B>s</B>, by this matrix to obtain the required check bits.
|
||||
|
||||
<P>In the <I>mixed representation</I>, the <I>M</I> by <I>M</I> matrix
|
||||
<B>A</B><SUP><SMALL>-1</SMALL></SUP> is computed and stored in a dense
|
||||
format, and the <I>M</I> by <I>K</I> matrix <B>B</B>, the right
|
||||
portion of the parity check matrix, is also stored, in a sparse format
|
||||
(see the <A HREF="mod2sparse.html">sparse modulo-2 matrix package</A>).
|
||||
To encode a message, the source vector <B>s</B> is first multiplied on
|
||||
the left by <B>B</B>, an operation which can be done very quickly if
|
||||
<B>B</B> is sparse (as it will be for LDPC codes). The result is then
|
||||
multiplied on the left by <B>A</B><SUP><SMALL>-1</SMALL></SUP>. If
|
||||
<I>M</I><<I>K</I>, the total time may be less than when using the
|
||||
dense representation above.
|
||||
|
||||
<P>The <I>sparse representation</I> goes further, and avoids
|
||||
explicitly computing <B>A</B><SUP><SMALL>-1</SMALL></SUP>, which tends
|
||||
to be dense even if <B>H</B> is sparse. Instead, a <I>LU
|
||||
decomposition</I> of <B>A</B> is found, consisting of a lower
|
||||
triangular matrix <B>L</B> and an upper triangular matrix <B>U</B> for
|
||||
which <B>LU</B>=<B>A</B>. The effect of multiplying <B>Bs</B>=<B>z</B> by
|
||||
<B>A</B><SUP><SMALL>-1</SMALL></SUP> can then be obtained by
|
||||
<BLOCKQUOTE>
|
||||
Solving <B>Ly</B>=<B>z</B> for <B>y</B> using forward substitution.<BR>
|
||||
Solving <B>Uc</B>=<B>y</B> for <B>c</B> using backward substitution.
|
||||
</BLOCKQUOTE>
|
||||
Both of these operations will be fast if <B>L</B> and <B>U</B> are
|
||||
sparse. Heuristics are used to try to achieve this, by rearranging the
|
||||
rows and columns of <B>H</B> in the process of selecting <B>A</B> and
|
||||
finding its LU decomposition.
|
||||
|
||||
|
||||
<P><A NAME="make-gen"><HR><B>make-gen</B>: Make a generator matrix from
|
||||
a parity check matrix.
|
||||
|
||||
<BLOCKQUOTE><PRE>
|
||||
make-gen <I>pchk-file gen-file method</I>
|
||||
</PRE>
|
||||
<BLOCKQUOTE>
|
||||
where <TT><I>method</I></TT> is one of the following:
|
||||
<BLOCKQUOTE><PRE>
|
||||
sparse [ first | mincol | minprod ] [ <I>abandon-num abandon-when</I> ]
|
||||
|
||||
dense [ <I>other-gen-file </I> ]
|
||||
|
||||
mixed [ <I>other-gen-file </I> ]
|
||||
</PRE></BLOCKQUOTE>
|
||||
</BLOCKQUOTE>
|
||||
</BLOCKQUOTE>
|
||||
|
||||
<P>Finds a generator matrix for the code whose parity check matrix is
|
||||
in <TT><I>pchk-file</I></TT>, and writes a representation of this
|
||||
generator matrix to <TT><I>gen-file</I></TT>. The remaining arguments
|
||||
specify what representation of the generator matrix is to be used (see
|
||||
the <A HREF="#gen-rep">description above</A>), and the method to be
|
||||
used in finding it. A message regarding the density of 1s in the
|
||||
resulting representation is displayed on standard error. For a sparse
|
||||
representation, a smaller number of 1s will produce faster encoding.
|
||||
|
||||
<P>All representations include a specification for how the columns of
|
||||
the parity check matrix should be re-ordered so that the message bits
|
||||
come last. References to columns of the parity check matrix below
|
||||
refer to their order after this reordering. For the <I>dense</I> and
|
||||
<I>mixed</I> representations, an <TT><I>other-gen-file</I></TT> may be
|
||||
specified, in which case the ordering of columns will be the same as
|
||||
the ordering stored in that file (which must produce a non-singular
|
||||
<B>A</B> matrix; redundant rows of <B>H</B> are not allowed with this
|
||||
option). Otherwise, <TT>make-gen</TT> decides on an appropriate
|
||||
ordering of columns itself. Note that the column rearrangement is
|
||||
recorded as part of the representation of the generator matrix; the
|
||||
parity check matrix as stored in its file is not altered.
|
||||
|
||||
<P>The <I>dense</I> representation consists of a dense representation
|
||||
of the matrix <B>A</B><SUP><SMALL>-1</SMALL></SUP><B>B</B>, where
|
||||
<B>A</B> is the matrix consisting of the first <I>M</I> columns (after
|
||||
reordering) of the parity check matrix, and <B>B</B> is the remaining
|
||||
columns. If <B>H</B> contains redundant rows, there is an additional
|
||||
reordering of columns of <B>A</B> in order create the same effect as
|
||||
if the redundant rows came last.
|
||||
|
||||
<P>The <I>mixed</I> representation consists of a dense representation
|
||||
of the matrix <B>A</B><SUP><SMALL>-1</SMALL></SUP>, where <B>A</B> is
|
||||
the matrix consisting of the first <I>M</I> columns (after reordering)
|
||||
of the parity check matrix. The remaining columns of the parity check
|
||||
matrix, making up the matrix <B>B</B>, are also part of the
|
||||
representation, but are not written to <TT><I>gen-file</I></TT>, since
|
||||
they can be obtained from <TT><I>pchk-file</I></TT>. As for mixed
|
||||
representations, an additional reordering of columns of <B>A</B> may
|
||||
be needed if <B>H</B> has redundant rows.
|
||||
|
||||
<P>A <I>sparse</I> representation consists of sparse representations
|
||||
of the <B>L</B> and <B>U</B> matrices, whose product is <B>A</B>, the
|
||||
first <I>M</I> columns of the parity check matrix (whose columns and
|
||||
rows may both have been reordered). The matrix <B>B</B>, consisting
|
||||
of the remaining columns of the parity check matrix, is also part of
|
||||
the representation, but it is not written to <TT><I>gen-file</I></TT>,
|
||||
since it can be obtained from <TT><I>pchk-file</I></TT>.
|
||||
|
||||
<P>If a sparse representation is chosen, arguments after
|
||||
<TT>sparse</TT> specify what heuristic is used when reordering columns
|
||||
and rows in order to try to make <B>L</B> and <B>U</B> as sparse as
|
||||
possible. The default if no heuristic is specified is
|
||||
<TT>minprod</TT>. If the <TT><I>abandon-num</I></TT> and
|
||||
<TT><I>abandon-when</I></TT> options are given, some information is
|
||||
discarded in order to speed up the process of finding <B>L</B> and
|
||||
<B>U</B>, at a possible cost in terms of how good a result is
|
||||
obtained. For details on these heuristics, see the descriptions of <A
|
||||
HREF="sparse-LU.html">sparse LU decomposition methods</A>.
|
||||
|
||||
<P><B>Example:</B> A dense representation of a generator matrix for the
|
||||
Hamming code created by the example for <A
|
||||
HREF="pchk.html#make-pchk"><TT>make-pchk</TT></A> can be created as follows:
|
||||
<UL><PRE>
|
||||
<LI>make-gen ham7.pchk ham7.gen dense
|
||||
Number of 1s per check in Inv(A) X B is 3.0
|
||||
</PRE></UL>
|
||||
|
||||
|
||||
<P><A NAME="print-gen"><HR><B>print-gen</B>: Print a representation of a
|
||||
generator matrix.
|
||||
|
||||
<BLOCKQUOTE><PRE>
|
||||
print-gen [ -d ] <I>gen-file</I>
|
||||
</PRE></BLOCKQUOTE>
|
||||
|
||||
<P>Prints in human-readable form the representation of the generator
|
||||
matrix that is stored in <TT><I>gen-file</I></TT>. The <B>-d</B>
|
||||
option causes the matrices involved to be printed in a dense format,
|
||||
even if they are stored in the file in a sparse format. See the <A
|
||||
HREF="#gen-rep">description above</A> for details of generator matrix
|
||||
representations. Note that the <B>L</B> matrix for a sparse representation
|
||||
will be lower triangular only after the rows are rearranged, and the <B>U</B>
|
||||
matrix will be upper triangular only after the columns are rearranged.
|
||||
The matrix <B>B</B> that is part of the sparse
|
||||
and mixed representations is not printed, since it is not stored
|
||||
in the <TT><I>gen-file</I></TT>, but is rather a subset of columns
|
||||
of the parity check matrix.
|
||||
|
||||
<P><B>Example:</B> The generator matrix for the
|
||||
Hamming code created by the example for <A
|
||||
HREF="#make-gen"><TT>make-gen</TT></A> can be printed as follows:
|
||||
<UL><PRE>
|
||||
<LI>print-gen ham7.gen
|
||||
|
||||
Generator matrix (dense representation):
|
||||
|
||||
Column order:
|
||||
|
||||
0 1 2 3 4 5 6
|
||||
|
||||
Inv(A) X B:
|
||||
|
||||
1 1 1 0
|
||||
1 1 0 1
|
||||
0 1 1 1
|
||||
</PRE></UL>
|
||||
For this example, the columns did not need to be rearranged, and hence the
|
||||
message bits will be in positions 3, 4, 5, and 6 of a codeword.
|
||||
|
||||
<P><A NAME="encode"><HR><B>encode</B>: Encode message blocks as codewords
|
||||
|
||||
<BLOCKQUOTE><PRE>
|
||||
encode [ -f ] <I>pchk-file gen-file source-file encoded-file</I>
|
||||
</PRE></BLOCKQUOTE>
|
||||
|
||||
Encodes message blocks of length <I>K</I>, read from
|
||||
<TT><I>source-file</I></TT>, as codewords of length <I>N</I>, which
|
||||
are written to <TT><I>encoded-file</I></TT>, replacing any previous
|
||||
data in this file. Here, <I>N</I> is the number of columns in the
|
||||
parity check matrix in <TT><I>pchk-file</I></TT>, and
|
||||
<I>K</I>=<I>N-M</I>, where <I>M</I> is the number of rows in the
|
||||
parity check matrix. The generator matrix used, from
|
||||
<TT><I>gen-file</I></TT>, determines which bits of the codeword are
|
||||
set to the message bits, and how the remaining check bits are
|
||||
computed. The generator matrix is created from
|
||||
<TT><I>pchk-file</I></TT> using <A HREF="#make-gen"><TT>make-gen</TT></A>.
|
||||
|
||||
<P>A newline is output at the end of each block written to
|
||||
<TT><I>encoded-file</I></TT>. Newlines in <TT><I>source-file</I></TT>
|
||||
are ignored.
|
||||
|
||||
<P>If the <B>-f</B> option is given, output to <TT><I>encoded-file</I></TT>
|
||||
is flushed after each block. This allows one to use encode as a server,
|
||||
reading blocks to encode from a named pipe, and writing the encoded block
|
||||
to another named pipe.
|
||||
|
||||
<HR>
|
||||
|
||||
<A HREF="index.html">Back to index for LDPC software</A>
|
||||
|
||||
</BODY></HTML>
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,180 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct void_;
|
||||
namespace result_of
|
||||
{
|
||||
template <
|
||||
typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_
|
||||
, typename Extra = void_
|
||||
>
|
||||
struct vector_tie;
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0>
|
||||
struct vector_tie< T0 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0&>
|
||||
vector_tie(T0 & arg0)
|
||||
{
|
||||
return vector<T0&>(
|
||||
arg0);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1>
|
||||
struct vector_tie< T0 , T1 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1)
|
||||
{
|
||||
return vector<T0& , T1&>(
|
||||
arg0 , arg1);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
struct vector_tie< T0 , T1 , T2 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2)
|
||||
{
|
||||
return vector<T0& , T1& , T2&>(
|
||||
arg0 , arg1 , arg2);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3&>(
|
||||
arg0 , arg1 , arg2 , arg3);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , void_ , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , void_ , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
struct vector_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , void_ >
|
||||
{
|
||||
typedef vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>
|
||||
vector_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9)
|
||||
{
|
||||
return vector<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9);
|
||||
}
|
||||
}}
|
||||
@@ -0,0 +1,143 @@
|
||||
subroutine filbig(dd,npts,f0,newdat,c4a,n4,sq0)
|
||||
|
||||
! Filter and downsample the real data in array dd(npts), sampled at 12000 Hz.
|
||||
! Output is complex, sampled at 1378.125 Hz.
|
||||
|
||||
use, intrinsic :: iso_c_binding
|
||||
use FFTW3
|
||||
use timer_module, only: timer
|
||||
|
||||
parameter (NSZ=3413)
|
||||
parameter (NFFT1=672000,NFFT2=77175)
|
||||
parameter (NZ2=1000)
|
||||
real*4 dd(npts) !Input data
|
||||
real*4 rca(NFFT1)
|
||||
complex ca(NFFT1/2+1) !FFT of input
|
||||
complex c4a(NFFT2) !Output data
|
||||
real*4 s(NZ2)
|
||||
real*8 df
|
||||
real halfpulse(8) !Impulse response of filter (one sided)
|
||||
complex cfilt(NFFT2) !Filter (complex; imag = 0)
|
||||
real rfilt(NFFT2) !Filter (real)
|
||||
type(C_PTR) :: plan1,plan2,plan3 !Pointers to FFTW plans
|
||||
logical first
|
||||
equivalence (rfilt,cfilt),(rca,ca)
|
||||
data first/.true./
|
||||
data halfpulse/114.97547150,36.57879257,-20.93789101, &
|
||||
5.89886379,1.59355187,-2.49138308,0.60910773,-0.04248129/
|
||||
common/refspec/dfref,ref(NSZ)
|
||||
common/patience/npatience,nthreads
|
||||
save first,plan1,plan2,plan3,rfilt,cfilt,df,ca
|
||||
|
||||
if(npts.lt.0) go to 900 !Clean up at end of program
|
||||
|
||||
if(first) then
|
||||
nflags=FFTW_ESTIMATE
|
||||
if(npatience.eq.1) nflags=FFTW_ESTIMATE_PATIENT
|
||||
if(npatience.eq.2) nflags=FFTW_MEASURE
|
||||
if(npatience.eq.3) nflags=FFTW_PATIENT
|
||||
if(npatience.eq.4) nflags=FFTW_EXHAUSTIVE
|
||||
|
||||
! Plan the FFTs just once
|
||||
!$omp critical(fftw) ! serialize non thread-safe FFTW3 calls
|
||||
call fftwf_plan_with_nthreads(nthreads)
|
||||
plan1=fftwf_plan_dft_r2c_1d(nfft1,rca,ca,nflags)
|
||||
call fftwf_plan_with_nthreads(1)
|
||||
plan2=fftwf_plan_dft_1d(nfft2,c4a,c4a,-1,nflags)
|
||||
plan3=fftwf_plan_dft_1d(nfft2,cfilt,cfilt,+1,nflags)
|
||||
!$omp end critical(fftw)
|
||||
|
||||
! Convert impulse response to filter function
|
||||
do i=1,nfft2
|
||||
cfilt(i)=0.
|
||||
enddo
|
||||
fac=0.00625/nfft1
|
||||
cfilt(1)=fac*halfpulse(1)
|
||||
do i=2,8
|
||||
cfilt(i)=fac*halfpulse(i)
|
||||
cfilt(nfft2+2-i)=fac*halfpulse(i)
|
||||
enddo
|
||||
call fftwf_execute_dft(plan3,cfilt,cfilt)
|
||||
|
||||
base=real(cfilt(nfft2/2+1))
|
||||
do i=1,nfft2
|
||||
rfilt(i)=real(cfilt(i))-base
|
||||
enddo
|
||||
|
||||
df=12000.d0/nfft1
|
||||
first=.false.
|
||||
endif
|
||||
|
||||
! When new data comes along, we need to compute a new "big FFT"
|
||||
! If we just have a new f0, continue with the existing data in ca.
|
||||
|
||||
if(newdat.ne.0) then
|
||||
call timer('FFTbig ',0)
|
||||
nz=min(npts,nfft1)
|
||||
rca(1:nz)=dd(1:nz)
|
||||
rca(nz+1:)=0.
|
||||
call fftwf_execute_dft_r2c(plan1,rca,ca)
|
||||
call timer('FFTbig ',1)
|
||||
|
||||
ib=0
|
||||
do j=1,NSZ
|
||||
ia=ib+1
|
||||
ib=nint(j*dfref/df)
|
||||
fac=sqrt(min(30.0,1.0/ref(j)))
|
||||
ca(ia:ib)=fac*conjg(ca(ia:ib))
|
||||
enddo
|
||||
newdat=0
|
||||
endif
|
||||
|
||||
! NB: f0 is the frequency at which we want our filter centered.
|
||||
! i0 is the bin number in ca closest to f0.
|
||||
call timer('loops ',0)
|
||||
i0=nint(f0/df) + 1
|
||||
nh=nfft2/2
|
||||
do i=1,nh !Copy data into c4a and apply
|
||||
j=i0+i-1 !the filter function
|
||||
if(j.ge.1 .and. j.le.nfft1/2+1) then
|
||||
c4a(i)=rfilt(i)*ca(j)
|
||||
else
|
||||
c4a(i)=0.
|
||||
endif
|
||||
enddo
|
||||
do i=nh+1,nfft2
|
||||
j=i0+i-1-nfft2
|
||||
! if(j.lt.1) j=j+nfft1 !nfft1 was nfft2
|
||||
if(j.ge.1) then
|
||||
c4a(i)=rfilt(i)*ca(j)
|
||||
else
|
||||
c4a(i)=rfilt(i)*conjg(ca(2-j))
|
||||
endif
|
||||
enddo
|
||||
|
||||
nadd=nfft2/NZ2
|
||||
i=0
|
||||
do j=1,NZ2
|
||||
s(j)=0.
|
||||
do n=1,nadd
|
||||
i=i+1
|
||||
s(j)=s(j) + real(c4a(i))**2 + aimag(c4a(i))**2
|
||||
enddo
|
||||
enddo
|
||||
call pctile(s,NZ2,30,sq0)
|
||||
call timer('loops ',1)
|
||||
|
||||
! Do the short reverse transform, to go back to time domain.
|
||||
call timer('FFTsmall',0)
|
||||
call fftwf_execute_dft(plan2,c4a,c4a)
|
||||
call timer('FFTsmall',1)
|
||||
n4=min(npts/8,nfft2)
|
||||
return
|
||||
|
||||
900 continue
|
||||
|
||||
!$omp critical(fftw) ! serialize non thread-safe FFTW3 calls
|
||||
call fftwf_destroy_plan(plan1)
|
||||
call fftwf_destroy_plan(plan2)
|
||||
call fftwf_destroy_plan(plan3)
|
||||
!$omp end critical(fftw)
|
||||
|
||||
return
|
||||
end subroutine filbig
|
||||
@@ -0,0 +1,126 @@
|
||||
program ft8sim
|
||||
|
||||
! Generate simulated data for a 15-second HF/6m mode using 8-FSK.
|
||||
! Output is saved to a *.wav file.
|
||||
|
||||
use wavhdr
|
||||
include 'ft8_params.f90' !Set various constants
|
||||
type(hdr) h !Header for .wav file
|
||||
character arg*12,fname*17,sorm*1
|
||||
character msg*22,msgsent*22
|
||||
character*6 mygrid6
|
||||
logical bcontest
|
||||
complex c0(0:NMAX-1)
|
||||
complex c(0:NMAX-1)
|
||||
integer itone(NN)
|
||||
integer*1 msgbits(KK)
|
||||
integer*2 iwave(NMAX) !Generated full-length waveform
|
||||
data mygrid6/'EM48 '/
|
||||
|
||||
! Get command-line argument(s)
|
||||
nargs=iargc()
|
||||
if(nargs.ne.8) then
|
||||
print*,'Usage: ft8sim "message" s|m f0 DT fdop del nfiles snr'
|
||||
print*,'Example: ft8sim "K1ABC W9XYZ EN37" m 1500.0 0.0 0.1 1.0 10 -18'
|
||||
print*,'s|m: "s" for single signal at 1500 Hz, "m" for 25 signals'
|
||||
print*,'f0 is ignored when sorm = m'
|
||||
print*,'Make nfiles negative to invoke 72-bit contest mode.'
|
||||
go to 999
|
||||
endif
|
||||
call getarg(1,msg) !Message to be transmitted
|
||||
call getarg(2,sorm) !s for single signal, m for multiple sigs
|
||||
if(sorm.eq."s") then
|
||||
print*,"Generating single signal at 1500 Hz."
|
||||
nsig=1
|
||||
elseif( sorm.eq."m") then
|
||||
print*,"Generating 25 signals per file."
|
||||
nsig=25
|
||||
else
|
||||
print*,"sorm parameter must be s (single) or m (multiple)."
|
||||
goto 999
|
||||
endif
|
||||
call getarg(3,arg)
|
||||
read(arg,*) f0 !Frequency (only used for single-signal)
|
||||
call getarg(4,arg)
|
||||
read(arg,*) xdt !Time offset from nominal (s)
|
||||
call getarg(5,arg)
|
||||
read(arg,*) fspread !Watterson frequency spread (Hz)
|
||||
call getarg(6,arg)
|
||||
read(arg,*) delay !Watterson delay (ms)
|
||||
call getarg(7,arg)
|
||||
read(arg,*) nfiles !Number of files
|
||||
call getarg(8,arg)
|
||||
read(arg,*) snrdb !SNR_2500
|
||||
|
||||
bcontest=nfiles.lt.0
|
||||
nfiles=abs(nfiles)
|
||||
twopi=8.0*atan(1.0)
|
||||
fs=12000.0 !Sample rate (Hz)
|
||||
dt=1.0/fs !Sample interval (s)
|
||||
tt=NSPS*dt !Duration of symbols (s)
|
||||
baud=1.0/tt !Keying rate (baud)
|
||||
bw=8*baud !Occupied bandwidth (Hz)
|
||||
txt=NZ*dt !Transmission length (s)
|
||||
bandwidth_ratio=2500.0/(fs/2.0)
|
||||
sig=sqrt(2*bandwidth_ratio) * 10.0**(0.05*snrdb)
|
||||
if(snrdb.gt.90.0) sig=1.0
|
||||
txt=NN*NSPS/12000.0
|
||||
i3bit=0 ! ### TEMPORARY ??? ###
|
||||
|
||||
! Source-encode, then get itone()
|
||||
call genft8(msg,mygrid6,bcontest,i3bit,msgsent,msgbits,itone)
|
||||
write(*,1000) f0,xdt,txt,snrdb,bw,msgsent
|
||||
1000 format('f0:',f9.3,' DT:',f6.2,' TxT:',f6.1,' SNR:',f6.1, &
|
||||
' BW:',f4.1,2x,a22)
|
||||
|
||||
write(*,'(28i1,1x,28i1)') msgbits(1:56)
|
||||
write(*,'(16i1)') msgbits(57:72)
|
||||
write(*,'(3i1)') msgbits(73:75)
|
||||
write(*,'(12i1)') msgbits(76:87)
|
||||
|
||||
! call sgran()
|
||||
do ifile=1,nfiles
|
||||
c=0.
|
||||
do isig=1,nsig
|
||||
c0=0.
|
||||
if(nsig.eq.25) then
|
||||
f0=(isig+2)*100.0
|
||||
endif
|
||||
k=-1 + nint((xdt+0.5+0.01*gran())/dt)
|
||||
! k=-1 + nint((xdt+0.5)/dt)
|
||||
phi=0.0
|
||||
do j=1,NN !Generate complex waveform
|
||||
dphi=twopi*(f0+itone(j)*baud)*dt
|
||||
do i=1,NSPS
|
||||
k=k+1
|
||||
phi=mod(phi+dphi,twopi)
|
||||
if(k.ge.0 .and. k.lt.NMAX) c0(k)=cmplx(cos(phi),sin(phi))
|
||||
enddo
|
||||
enddo
|
||||
if(fspread.ne.0.0 .or. delay.ne.0.0) call watterson(c0,NMAX,fs,delay,fspread)
|
||||
c=c+sig*c0
|
||||
enddo
|
||||
if(snrdb.lt.90) then
|
||||
do i=0,NMAX-1 !Add gaussian noise at specified SNR
|
||||
xnoise=gran()
|
||||
ynoise=gran()
|
||||
c(i)=c(i) + cmplx(xnoise,ynoise)
|
||||
enddo
|
||||
endif
|
||||
|
||||
fac=32767.0
|
||||
rms=100.0
|
||||
if(snrdb.ge.90.0) iwave(1:NMAX)=nint(fac*real(c))
|
||||
if(snrdb.lt.90.0) iwave(1:NMAX)=nint(rms*real(c))
|
||||
|
||||
h=default_header(12000,NMAX)
|
||||
write(fname,1102) ifile
|
||||
1102 format('000000_',i6.6,'.wav')
|
||||
open(10,file=fname,status='unknown',access='stream')
|
||||
write(10) h,iwave !Save to *.wav file
|
||||
close(10)
|
||||
write(*,1110) ifile,xdt,f0,snrdb,fname
|
||||
1110 format(i4,f7.2,f8.2,f7.1,2x,a17)
|
||||
enddo
|
||||
|
||||
999 end program ft8sim
|
||||
@@ -0,0 +1,64 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2003 Joel de Guzman
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
=============================================================================*/
|
||||
#if !defined(BOOST_SPIRIT_SAFE_BOOL_HPP)
|
||||
#define BOOST_SPIRIT_SAFE_BOOL_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/spirit/home/classic/namespace.hpp>
|
||||
|
||||
namespace boost { namespace spirit {
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
||||
|
||||
namespace impl
|
||||
{
|
||||
template <typename T>
|
||||
struct no_base {};
|
||||
|
||||
template <typename T>
|
||||
struct safe_bool_impl
|
||||
{
|
||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
|
||||
void stub(T*) {};
|
||||
typedef void (safe_bool_impl::*type)(T*);
|
||||
#else
|
||||
typedef T* TP; // workaround to make parsing easier
|
||||
TP stub;
|
||||
typedef TP safe_bool_impl::*type;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
template <typename DerivedT, typename BaseT = impl::no_base<DerivedT> >
|
||||
struct safe_bool : BaseT
|
||||
{
|
||||
private:
|
||||
typedef impl::safe_bool_impl<DerivedT> impl_t;
|
||||
typedef typename impl_t::type bool_type;
|
||||
|
||||
public:
|
||||
operator bool_type() const
|
||||
{
|
||||
return static_cast<const DerivedT*>(this)->operator_bool() ?
|
||||
&impl_t::stub : 0;
|
||||
}
|
||||
|
||||
operator bool_type()
|
||||
{
|
||||
return static_cast<DerivedT*>(this)->operator_bool() ?
|
||||
&impl_t::stub : 0;
|
||||
}
|
||||
};
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
// abi_sufffix header -------------------------------------------------------//
|
||||
|
||||
// (c) Copyright John Maddock 2003
|
||||
|
||||
// Use, modification and distribution are subject to the Boost Software License,
|
||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt).
|
||||
|
||||
// This header should be #included AFTER code that was preceded by a #include
|
||||
// <boost/config/abi_prefix.hpp>.
|
||||
|
||||
#ifndef BOOST_CONFIG_ABI_PREFIX_HPP
|
||||
# error Header boost/config/abi_suffix.hpp must only be used after boost/config/abi_prefix.hpp
|
||||
#else
|
||||
# undef BOOST_CONFIG_ABI_PREFIX_HPP
|
||||
#endif
|
||||
|
||||
// the suffix header occurs after all of our code:
|
||||
#ifdef BOOST_HAS_ABI_HEADERS
|
||||
# include BOOST_ABI_SUFFIX
|
||||
#endif
|
||||
|
||||
#if defined( __BORLANDC__ )
|
||||
#pragma nopushoptwarn
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
|
||||
#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// unescape.hpp
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
#include <boost/iterator/iterator_adaptor.hpp>
|
||||
#include <boost/pointee.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
namespace iterators {
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// class used by text archives to translate char strings to wchar_t
|
||||
// strings of the currently selected locale
|
||||
template<class Derived, class Base>
|
||||
class unescape
|
||||
: public boost::iterator_adaptor<
|
||||
unescape<Derived, Base>,
|
||||
Base,
|
||||
typename pointee<Base>::type,
|
||||
single_pass_traversal_tag,
|
||||
typename pointee<Base>::type
|
||||
>
|
||||
{
|
||||
friend class boost::iterator_core_access;
|
||||
typedef typename boost::iterator_adaptor<
|
||||
unescape<Derived, Base>,
|
||||
Base,
|
||||
typename pointee<Base>::type,
|
||||
single_pass_traversal_tag,
|
||||
typename pointee<Base>::type
|
||||
> super_t;
|
||||
|
||||
typedef unescape<Derived, Base> this_t;
|
||||
public:
|
||||
typedef typename this_t::value_type value_type;
|
||||
typedef typename this_t::reference reference;
|
||||
private:
|
||||
value_type dereference_impl() {
|
||||
if(! m_full){
|
||||
m_current_value = static_cast<Derived *>(this)->drain();
|
||||
m_full = true;
|
||||
}
|
||||
return m_current_value;
|
||||
}
|
||||
|
||||
reference dereference() const {
|
||||
return const_cast<this_t *>(this)->dereference_impl();
|
||||
}
|
||||
|
||||
value_type m_current_value;
|
||||
bool m_full;
|
||||
|
||||
void increment(){
|
||||
++(this->base_reference());
|
||||
dereference_impl();
|
||||
m_full = false;
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
unescape(Base base) :
|
||||
super_t(base),
|
||||
m_full(false)
|
||||
{}
|
||||
|
||||
};
|
||||
|
||||
} // namespace iterators
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
|
||||
@@ -0,0 +1,44 @@
|
||||
|
||||
#ifndef BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED
|
||||
#define BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org/libs/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
#include <boost/mpl/pop_front_fwd.hpp>
|
||||
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
|
||||
#include <boost/mpl/aux_/config/workaround.hpp>
|
||||
#include <boost/mpl/aux_/config/msvc.hpp>
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
// no default implementation; the definition is needed to make MSVC happy
|
||||
|
||||
template< typename Tag >
|
||||
struct pop_front_impl
|
||||
{
|
||||
template< typename Sequence > struct apply
|
||||
// conservatively placed, but maybe should go outside surrounding
|
||||
// braces.
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
|
||||
{
|
||||
typedef int type;
|
||||
}
|
||||
#endif
|
||||
;
|
||||
};
|
||||
|
||||
BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, pop_front_impl)
|
||||
|
||||
}}
|
||||
|
||||
#endif // BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED
|
||||
@@ -0,0 +1,172 @@
|
||||
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
||||
// 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/utility for most recent version including documentation.
|
||||
|
||||
// call_traits: defines typedefs for function usage
|
||||
// (see libs/utility/call_traits.htm)
|
||||
|
||||
/* Release notes:
|
||||
23rd July 2000:
|
||||
Fixed array specialization. (JM)
|
||||
Added Borland specific fixes for reference types
|
||||
(issue raised by Steve Cleary).
|
||||
*/
|
||||
|
||||
#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
|
||||
#define BOOST_DETAIL_CALL_TRAITS_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#include <boost/config.hpp>
|
||||
#endif
|
||||
#include <cstddef>
|
||||
|
||||
#include <boost/type_traits/is_arithmetic.hpp>
|
||||
#include <boost/type_traits/is_enum.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
namespace boost{
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <typename T, bool small_>
|
||||
struct ct_imp2
|
||||
{
|
||||
typedef const T& param_type;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct ct_imp2<T, true>
|
||||
{
|
||||
typedef const T param_type;
|
||||
};
|
||||
|
||||
template <typename T, bool isp, bool b1, bool b2>
|
||||
struct ct_imp
|
||||
{
|
||||
typedef const T& param_type;
|
||||
};
|
||||
|
||||
template <typename T, bool isp, bool b2>
|
||||
struct ct_imp<T, isp, true, b2>
|
||||
{
|
||||
typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
|
||||
};
|
||||
|
||||
template <typename T, bool isp, bool b1>
|
||||
struct ct_imp<T, isp, b1, true>
|
||||
{
|
||||
typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
|
||||
};
|
||||
|
||||
template <typename T, bool b1, bool b2>
|
||||
struct ct_imp<T, true, b1, b2>
|
||||
{
|
||||
typedef const T param_type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct call_traits
|
||||
{
|
||||
public:
|
||||
typedef T value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
//
|
||||
// C++ Builder workaround: we should be able to define a compile time
|
||||
// constant and pass that as a single template parameter to ct_imp<T,bool>,
|
||||
// however compiler bugs prevent this - instead pass three bool's to
|
||||
// ct_imp<T,bool,bool,bool> and add an extra partial specialisation
|
||||
// of ct_imp to handle the logic. (JM)
|
||||
typedef typename boost::detail::ct_imp<
|
||||
T,
|
||||
::boost::is_pointer<T>::value,
|
||||
::boost::is_arithmetic<T>::value,
|
||||
::boost::is_enum<T>::value
|
||||
>::param_type param_type;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct call_traits<T&>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
|
||||
#if BOOST_WORKAROUND( __BORLANDC__, < 0x5A0 )
|
||||
// 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 <typename T>
|
||||
struct call_traits<T&const>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
template <typename T>
|
||||
struct call_traits<T&volatile>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
template <typename T>
|
||||
struct call_traits<T&const volatile>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct call_traits< T * >
|
||||
{
|
||||
typedef T * value_type;
|
||||
typedef T * & reference;
|
||||
typedef T * const & const_reference;
|
||||
typedef T * const param_type; // hh removed const
|
||||
};
|
||||
#endif
|
||||
#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
|
||||
template <typename T, std::size_t N>
|
||||
struct call_traits<T [N]>
|
||||
{
|
||||
private:
|
||||
typedef T array_type[N];
|
||||
public:
|
||||
// degrades array to pointer:
|
||||
typedef const T* value_type;
|
||||
typedef array_type& reference;
|
||||
typedef const array_type& const_reference;
|
||||
typedef const T* const param_type;
|
||||
};
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
struct call_traits<const T [N]>
|
||||
{
|
||||
private:
|
||||
typedef const T array_type[N];
|
||||
public:
|
||||
// degrades array to pointer:
|
||||
typedef const T* value_type;
|
||||
typedef array_type& reference;
|
||||
typedef const array_type& const_reference;
|
||||
typedef const T* const param_type;
|
||||
};
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#endif // BOOST_DETAIL_CALL_TRAITS_HPP
|
||||
@@ -0,0 +1,48 @@
|
||||
/*=============================================================================
|
||||
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)
|
||||
==============================================================================*/
|
||||
#ifndef BOOST_PP_IS_ITERATING
|
||||
#if !defined(FUSION_LIST_FORWARD_CTOR_07172005_0113)
|
||||
#define FUSION_LIST_FORWARD_CTOR_07172005_0113
|
||||
|
||||
#include <boost/preprocessor/iterate.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_shifted.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
|
||||
#define FUSION_LIST_CTOR_MAKE_CONS(z, n, type) tie_cons(BOOST_PP_CAT(_, n)
|
||||
#define FUSION_LIST_CL_PAREN(z, n, type) )
|
||||
|
||||
#define BOOST_PP_FILENAME_1 \
|
||||
<boost/fusion/container/list/detail/cpp03/list_forward_ctor.hpp>
|
||||
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#undef FUSION_LIST_CTOR_MAKE_CONS
|
||||
#undef FUSION_LIST_CL_PAREN
|
||||
|
||||
#endif
|
||||
#else // defined(BOOST_PP_IS_ITERATING)
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Preprocessor vertical repetition code
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
#if N == 1
|
||||
explicit
|
||||
#endif
|
||||
list(BOOST_PP_ENUM_BINARY_PARAMS(
|
||||
N, typename detail::call_param<T, >::type arg))
|
||||
: inherited_type(list_to_cons::call(BOOST_PP_ENUM_PARAMS(N, arg)))
|
||||
{}
|
||||
|
||||
#undef N
|
||||
#endif // defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
svn status
|
||||
@@ -0,0 +1,71 @@
|
||||
/*=============================================================================
|
||||
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_END_IMPL_07162005_1028)
|
||||
#define FUSION_END_IMPL_07162005_1028
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/view/transform_view/transform_view_fwd.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename First, typename F>
|
||||
struct transform_view_iterator;
|
||||
|
||||
template <typename First1, typename First2, typename F>
|
||||
struct transform_view_iterator2;
|
||||
|
||||
namespace extension
|
||||
{
|
||||
template <typename Tag>
|
||||
struct end_impl;
|
||||
|
||||
// Unary Version
|
||||
template <>
|
||||
struct end_impl<transform_view_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef typename Sequence::last_type last_type;
|
||||
typedef typename Sequence::transform_type transform_type;
|
||||
typedef transform_view_iterator<last_type, transform_type> type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type
|
||||
call(Sequence& s)
|
||||
{
|
||||
return type(s.last(), s.f);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
// Binary Version
|
||||
template <>
|
||||
struct end_impl<transform_view2_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
{
|
||||
typedef typename Sequence::last1_type last1_type;
|
||||
typedef typename Sequence::last2_type last2_type;
|
||||
typedef typename Sequence::transform_type transform_type;
|
||||
typedef transform_view_iterator2<last1_type, last2_type, transform_type> type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type
|
||||
call(Sequence& s)
|
||||
{
|
||||
return type(s.last1(), s.last2(), s.f);
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
// 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_DIM_IMPL_HPP
|
||||
#define BOOST_UNITS_DIM_IMPL_HPP
|
||||
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/less.hpp>
|
||||
|
||||
#include <boost/units/units_fwd.hpp>
|
||||
|
||||
/// \file
|
||||
/// \brief Class encapsulating a dimension tag/value pair
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
namespace detail {
|
||||
|
||||
struct dim_tag;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
namespace mpl {
|
||||
|
||||
/// Less than comparison for sorting @c dim.
|
||||
template<>
|
||||
struct less_impl<boost::units::detail::dim_tag, boost::units::detail::dim_tag>
|
||||
{
|
||||
template<class T0, class T1>
|
||||
struct apply : mpl::less<typename T0::tag_type, typename T1::tag_type> {};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
namespace units {
|
||||
|
||||
template<class Tag, class Exponent>
|
||||
struct dim;
|
||||
|
||||
template<long N, long D>
|
||||
class static_rational;
|
||||
|
||||
namespace detail {
|
||||
|
||||
/// Extract @c tag_type from a @c dim.
|
||||
template<typename T>
|
||||
struct get_tag
|
||||
{
|
||||
typedef typename T::tag_type type;
|
||||
};
|
||||
|
||||
/// Extract @c value_type from a @c dim.
|
||||
template<typename T>
|
||||
struct get_value
|
||||
{
|
||||
typedef typename T::value_type type;
|
||||
};
|
||||
|
||||
/// Determine if a @c dim is empty (has a zero exponent).
|
||||
template<class T>
|
||||
struct is_empty_dim;
|
||||
|
||||
template<typename T>
|
||||
struct is_empty_dim< dim<T, static_rational<0, 1> > > :
|
||||
mpl::true_
|
||||
{ };
|
||||
|
||||
template<typename T, typename V>
|
||||
struct is_empty_dim< dim<T, V> > :
|
||||
mpl::false_
|
||||
{ };
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNITS_DIM_IMPL_HPP
|
||||
@@ -0,0 +1,275 @@
|
||||
// (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
|
||||
/// Defines @ref boost::unit_test::test_unit "test_unit", @ref boost::unit_test::test_case "test_case",
|
||||
/// @ref boost::unit_test::test_suite "test_suite" and @ref boost::unit_test::master_test_suite_t "master_test_suite_t"
|
||||
// ***************************************************************************
|
||||
|
||||
#ifndef BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
|
||||
#define BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
|
||||
|
||||
// Boost.Test
|
||||
#include <boost/test/detail/config.hpp>
|
||||
#include <boost/test/detail/global_typedef.hpp>
|
||||
#include <boost/test/detail/fwd_decl.hpp>
|
||||
|
||||
#include <boost/test/tree/decorator.hpp>
|
||||
#include <boost/test/tree/fixture.hpp>
|
||||
|
||||
#include <boost/test/tools/assertion_result.hpp>
|
||||
|
||||
#include <boost/test/utils/class_properties.hpp>
|
||||
|
||||
// Boost
|
||||
#include <boost/function/function0.hpp>
|
||||
#include <boost/function/function1.hpp>
|
||||
|
||||
// STL
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
||||
#include <boost/test/detail/suppress_warnings.hpp>
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
namespace boost {
|
||||
namespace unit_test {
|
||||
|
||||
namespace framework {
|
||||
class state;
|
||||
}
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** test_unit ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
typedef std::vector<test_unit_id> test_unit_id_list;
|
||||
|
||||
class BOOST_TEST_DECL test_unit {
|
||||
public:
|
||||
enum { type = TUT_ANY };
|
||||
enum run_status { RS_DISABLED, RS_ENABLED, RS_INHERIT, RS_INVALID };
|
||||
|
||||
typedef std::vector<test_unit_id> id_list;
|
||||
typedef std::vector<test_unit_fixture_ptr> fixture_list_t;
|
||||
typedef BOOST_READONLY_PROPERTY(test_unit_id,(framework::state)) id_t;
|
||||
typedef BOOST_READONLY_PROPERTY(test_unit_id,(test_suite)) parent_id_t;
|
||||
typedef BOOST_READONLY_PROPERTY(id_list,(test_unit)) id_list_t;
|
||||
typedef std::vector<decorator::base_ptr> decor_list_t;
|
||||
typedef BOOST_READONLY_PROPERTY(std::vector<std::string>,(test_unit)) label_list_t;
|
||||
|
||||
typedef boost::function<test_tools::assertion_result (test_unit_id)> precondition_t;
|
||||
typedef BOOST_READONLY_PROPERTY(std::vector<precondition_t>,(test_unit)) precond_list_t;
|
||||
|
||||
// preconditions management
|
||||
void depends_on( test_unit* tu );
|
||||
void add_precondition( precondition_t const& );
|
||||
test_tools::assertion_result check_preconditions() const;
|
||||
|
||||
// labels management
|
||||
void add_label( const_string l );
|
||||
bool has_label( const_string l ) const;
|
||||
|
||||
// helper access methods
|
||||
void increase_exp_fail( counter_t num );
|
||||
bool is_enabled() const { return p_run_status == RS_ENABLED; }
|
||||
std::string full_name() const;
|
||||
|
||||
// Public r/o properties
|
||||
test_unit_type const p_type; ///< type for this test unit
|
||||
const_string const p_type_name; ///< "case"/"suite"/"module"
|
||||
const_string const p_file_name;
|
||||
std::size_t const p_line_num;
|
||||
id_t p_id; ///< unique id for this test unit
|
||||
parent_id_t p_parent_id; ///< parent test suite id
|
||||
label_list_t p_labels; ///< list of labels associated with this test unit
|
||||
|
||||
id_list_t p_dependencies; ///< list of test units this one depends on
|
||||
precond_list_t p_preconditions; ///< user supplied preconditions for this test unit;
|
||||
|
||||
// Public r/w properties
|
||||
readwrite_property<std::string> p_name; ///< name for this test unit
|
||||
readwrite_property<std::string> p_description; ///< description for this test unit
|
||||
readwrite_property<unsigned> p_timeout; ///< timeout for the test unit execution in seconds
|
||||
readwrite_property<counter_t> p_expected_failures; ///< number of expected failures in this test unit
|
||||
|
||||
readwrite_property<run_status> p_default_status; ///< run status obtained by this unit during setup phase
|
||||
readwrite_property<run_status> p_run_status; ///< run status assigned to this unit before execution phase after applying all filters
|
||||
|
||||
readwrite_property<counter_t> p_sibling_rank; ///< rank of this test unit amoung siblings of the same parent
|
||||
|
||||
readwrite_property<decor_list_t> p_decorators; ///< automatically assigned decorators; execution is delayed till framework::finalize_setup_phase function
|
||||
readwrite_property<fixture_list_t> p_fixtures; ///< fixtures associated with this test unit
|
||||
|
||||
protected:
|
||||
~test_unit();
|
||||
// Constructor
|
||||
test_unit( const_string tu_name, const_string tc_file, std::size_t tc_line, test_unit_type t );
|
||||
// Master test suite constructor
|
||||
explicit test_unit( const_string module_name );
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** test_unit_generator ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
class BOOST_TEST_DECL test_unit_generator {
|
||||
public:
|
||||
virtual test_unit* next() const = 0;
|
||||
|
||||
protected:
|
||||
BOOST_TEST_PROTECTED_VIRTUAL ~test_unit_generator() {}
|
||||
};
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** test_case ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
class BOOST_TEST_DECL test_case : public test_unit {
|
||||
public:
|
||||
enum { type = TUT_CASE };
|
||||
|
||||
// Constructor
|
||||
test_case( const_string tc_name, boost::function<void ()> const& test_func );
|
||||
test_case( const_string tc_name, const_string tc_file, std::size_t tc_line, boost::function<void ()> const& test_func );
|
||||
|
||||
// Public property
|
||||
typedef BOOST_READONLY_PROPERTY(boost::function<void ()>,(test_case)) test_func;
|
||||
|
||||
test_func p_test_func;
|
||||
|
||||
private:
|
||||
friend class framework::state;
|
||||
~test_case() {}
|
||||
};
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** test_suite ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
//! Class representing test suites
|
||||
class BOOST_TEST_DECL test_suite : public test_unit {
|
||||
public:
|
||||
enum { type = TUT_SUITE };
|
||||
|
||||
// Constructor
|
||||
explicit test_suite( const_string ts_name, const_string ts_file, std::size_t ts_line );
|
||||
|
||||
// test unit list management
|
||||
|
||||
/*!@brief Adds a test unit to a test suite.
|
||||
*
|
||||
* It is possible to specify the timeout and the expected failures.
|
||||
*/
|
||||
void add( test_unit* tu, counter_t expected_failures = 0, unsigned timeout = 0 );
|
||||
|
||||
/// @overload
|
||||
void add( test_unit_generator const& gen, unsigned timeout = 0 );
|
||||
|
||||
/// @overload
|
||||
void add( test_unit_generator const& gen, decorator::collector& decorators );
|
||||
|
||||
//! Removes a test from the test suite.
|
||||
void remove( test_unit_id id );
|
||||
|
||||
|
||||
// access methods
|
||||
test_unit_id get( const_string tu_name ) const;
|
||||
std::size_t size() const { return m_children.size(); }
|
||||
|
||||
protected:
|
||||
// Master test suite constructor
|
||||
explicit test_suite( const_string module_name );
|
||||
|
||||
friend BOOST_TEST_DECL
|
||||
void traverse_test_tree( test_suite const&, test_tree_visitor&, bool );
|
||||
friend class framework::state;
|
||||
virtual ~test_suite() {}
|
||||
|
||||
typedef std::multimap<counter_t,test_unit_id> children_per_rank;
|
||||
// Data members
|
||||
|
||||
test_unit_id_list m_children;
|
||||
children_per_rank m_ranked_children; ///< maps child sibling rank to list of children with that rank
|
||||
};
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** master_test_suite ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
class BOOST_TEST_DECL master_test_suite_t : public test_suite {
|
||||
public:
|
||||
master_test_suite_t();
|
||||
|
||||
// Data members
|
||||
int argc;
|
||||
char** argv;
|
||||
};
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** user_tc_method_invoker ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
namespace ut_detail {
|
||||
|
||||
BOOST_TEST_DECL std::string normalize_test_case_name( const_string tu_name );
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
template<typename InstanceType,typename UserTestCase>
|
||||
struct user_tc_method_invoker {
|
||||
typedef void (UserTestCase::*TestMethod )();
|
||||
|
||||
user_tc_method_invoker( shared_ptr<InstanceType> inst, TestMethod test_method )
|
||||
: m_inst( inst ), m_test_method( test_method ) {}
|
||||
|
||||
void operator()() { ((*m_inst).*m_test_method)(); }
|
||||
|
||||
shared_ptr<InstanceType> m_inst;
|
||||
TestMethod m_test_method;
|
||||
};
|
||||
|
||||
} // namespace ut_detail
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** make_test_case ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
inline test_case*
|
||||
make_test_case( boost::function<void ()> const& test_func, const_string tc_name, const_string tc_file, std::size_t tc_line )
|
||||
{
|
||||
return new test_case( ut_detail::normalize_test_case_name( tc_name ), tc_file, tc_line, test_func );
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
template<typename UserTestCase, typename InstanceType>
|
||||
inline test_case*
|
||||
make_test_case( void (UserTestCase::* test_method )(),
|
||||
const_string tc_name,
|
||||
const_string tc_file,
|
||||
std::size_t tc_line,
|
||||
boost::shared_ptr<InstanceType> user_test_case )
|
||||
{
|
||||
return new test_case( ut_detail::normalize_test_case_name( tc_name ),
|
||||
tc_file,
|
||||
tc_line,
|
||||
ut_detail::user_tc_method_invoker<InstanceType,UserTestCase>( user_test_case, test_method ) );
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
} // namespace unit_test
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/test/detail/enable_warnings.hpp>
|
||||
|
||||
#endif // BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
|
||||
@@ -0,0 +1,295 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
// *Preprocessed* version of the main "reverse_iter_fold_impl.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl { namespace aux {
|
||||
|
||||
/// forward declaration
|
||||
|
||||
template<
|
||||
long N
|
||||
, typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_impl;
|
||||
|
||||
template< long N >
|
||||
struct reverse_iter_fold_chunk;
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<0>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef fwd_state0 bkwd_state0;
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter0 iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<1>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
|
||||
|
||||
typedef fwd_state1 bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter1 iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<2>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
|
||||
|
||||
typedef fwd_state2 bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter2 iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<3>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
|
||||
typedef typename mpl::next<iter2>::type iter3;
|
||||
|
||||
|
||||
typedef fwd_state3 bkwd_state3;
|
||||
typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter3 iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct reverse_iter_fold_chunk<4>
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
|
||||
typedef typename mpl::next<iter2>::type iter3;
|
||||
typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
|
||||
typedef typename mpl::next<iter3>::type iter4;
|
||||
|
||||
|
||||
typedef fwd_state4 bkwd_state4;
|
||||
typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
|
||||
typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef iter4 iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template< long N >
|
||||
struct reverse_iter_fold_chunk
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef First iter0;
|
||||
typedef State fwd_state0;
|
||||
typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
|
||||
typedef typename mpl::next<iter0>::type iter1;
|
||||
typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
|
||||
typedef typename mpl::next<iter1>::type iter2;
|
||||
typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
|
||||
typedef typename mpl::next<iter2>::type iter3;
|
||||
typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
|
||||
typedef typename mpl::next<iter3>::type iter4;
|
||||
|
||||
|
||||
typedef reverse_iter_fold_impl<
|
||||
( (N - 4) < 0 ? 0 : N - 4 )
|
||||
, iter4
|
||||
, Last
|
||||
, fwd_state4
|
||||
, BackwardOp
|
||||
, ForwardOp
|
||||
> nested_chunk;
|
||||
|
||||
typedef typename nested_chunk::state bkwd_state4;
|
||||
typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
|
||||
typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
|
||||
typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
|
||||
typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
|
||||
|
||||
|
||||
typedef bkwd_state0 state;
|
||||
typedef typename nested_chunk::iterator iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_step;
|
||||
|
||||
template<
|
||||
typename Last
|
||||
, typename State
|
||||
>
|
||||
struct reverse_iter_fold_null_step
|
||||
{
|
||||
typedef Last iterator;
|
||||
typedef State state;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct reverse_iter_fold_chunk< -1 >
|
||||
{
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct result_
|
||||
{
|
||||
typedef typename if_<
|
||||
typename is_same< First,Last >::type
|
||||
, reverse_iter_fold_null_step< Last,State >
|
||||
, reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp >
|
||||
>::type res_;
|
||||
|
||||
typedef typename res_::state state;
|
||||
typedef typename res_::iterator iterator;
|
||||
};
|
||||
};
|
||||
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_step
|
||||
{
|
||||
typedef reverse_iter_fold_chunk< -1 >::template result_<
|
||||
typename mpl::next<First>::type
|
||||
, Last
|
||||
, typename apply2< ForwardOp,State,First >::type
|
||||
, BackwardOp
|
||||
, ForwardOp
|
||||
> nested_step;
|
||||
|
||||
typedef typename apply2<
|
||||
BackwardOp
|
||||
, typename nested_step::state
|
||||
, First
|
||||
>::type state;
|
||||
|
||||
typedef typename nested_step::iterator iterator;
|
||||
};
|
||||
|
||||
template<
|
||||
long N
|
||||
, typename First
|
||||
, typename Last
|
||||
, typename State
|
||||
, typename BackwardOp
|
||||
, typename ForwardOp
|
||||
>
|
||||
struct reverse_iter_fold_impl
|
||||
: reverse_iter_fold_chunk<N>
|
||||
::template result_< First,Last,State,BackwardOp,ForwardOp >
|
||||
{
|
||||
};
|
||||
|
||||
}}}
|
||||
@@ -0,0 +1,268 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 1999-2003 Jeremiah Willcock
|
||||
Copyright (c) 1999-2003 Jaakko Jarvi
|
||||
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_MANIP_05052005_1200)
|
||||
#define FUSION_MANIP_05052005_1200
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/config.hpp>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <cctype>
|
||||
|
||||
// Tuple I/O manipulators
|
||||
|
||||
#define FUSION_GET_CHAR_TYPE(T) typename T::char_type
|
||||
#define FUSION_GET_TRAITS_TYPE(T) typename T::traits_type
|
||||
|
||||
#define FUSION_STRING_OF_STREAM(Stream) \
|
||||
std::basic_string< \
|
||||
FUSION_GET_CHAR_TYPE(Stream) \
|
||||
, FUSION_GET_TRAITS_TYPE(Stream) \
|
||||
>
|
||||
|
||||
//$$$ these should be part of the public API$$$
|
||||
//$$$ rename tuple_open, tuple_close and tuple_delimiter to
|
||||
// open, close and delimeter and add these synonyms to the
|
||||
// TR1 tuple module.
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template <typename Tag>
|
||||
int get_xalloc_index(Tag* = 0)
|
||||
{
|
||||
// each Tag will have a unique index
|
||||
static int index = std::ios::xalloc();
|
||||
return index;
|
||||
}
|
||||
|
||||
template <typename Stream, typename Tag, typename T>
|
||||
struct stream_data
|
||||
{
|
||||
struct arena
|
||||
{
|
||||
~arena()
|
||||
{
|
||||
for (
|
||||
typename std::vector<T*>::iterator i = data.begin()
|
||||
; i != data.end()
|
||||
; ++i)
|
||||
{
|
||||
delete *i;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<T*> data;
|
||||
};
|
||||
|
||||
static void attach(Stream& stream, T const& data)
|
||||
{
|
||||
static arena ar; // our arena
|
||||
ar.data.push_back(new T(data));
|
||||
stream.pword(get_xalloc_index<Tag>()) = ar.data.back();
|
||||
}
|
||||
|
||||
static T const* get(Stream& stream)
|
||||
{
|
||||
return (T const*)stream.pword(get_xalloc_index<Tag>());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Tag, typename Stream>
|
||||
class string_ios_manip
|
||||
{
|
||||
public:
|
||||
|
||||
typedef FUSION_STRING_OF_STREAM(Stream) string_type;
|
||||
|
||||
typedef stream_data<Stream, Tag, string_type> stream_data_t;
|
||||
|
||||
string_ios_manip(Stream& str_)
|
||||
: stream(str_)
|
||||
{}
|
||||
|
||||
void
|
||||
set(string_type const& s)
|
||||
{
|
||||
stream_data_t::attach(stream, s);
|
||||
}
|
||||
|
||||
void
|
||||
print(char const* default_) const
|
||||
{
|
||||
// print a delimiter
|
||||
string_type const* p = stream_data_t::get(stream);
|
||||
if (p)
|
||||
stream << *p;
|
||||
else
|
||||
stream << default_;
|
||||
}
|
||||
|
||||
void
|
||||
read(char const* default_) const
|
||||
{
|
||||
// read a delimiter
|
||||
string_type const* p = stream_data_t::get(stream);
|
||||
std::ws(stream);
|
||||
|
||||
if (p)
|
||||
{
|
||||
typedef typename string_type::const_iterator iterator;
|
||||
for (iterator i = p->begin(); i != p->end(); ++i)
|
||||
check_delim(*i);
|
||||
}
|
||||
else
|
||||
{
|
||||
while (*default_)
|
||||
check_delim(*default_++);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
template <typename Char>
|
||||
void
|
||||
check_delim(Char c) const
|
||||
{
|
||||
if (!isspace(c))
|
||||
{
|
||||
if (stream.get() != c)
|
||||
{
|
||||
stream.unget();
|
||||
stream.setstate(std::ios::failbit);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Stream& stream;
|
||||
|
||||
private:
|
||||
// silence MSVC warning C4512: assignment operator could not be generated
|
||||
string_ios_manip& operator= (string_ios_manip const&);
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
|
||||
#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
|
||||
|
||||
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
|
||||
template <typename Char, typename Traits> \
|
||||
inline detail::name##_type<Char, Traits> \
|
||||
name(const std::basic_string<Char, Traits>& s) \
|
||||
{ \
|
||||
return detail::name##_type<Char, Traits>(s); \
|
||||
} \
|
||||
\
|
||||
inline detail::name##_type<char> \
|
||||
name(char const* s) \
|
||||
{ \
|
||||
return detail::name##_type<char>(std::basic_string<char>(s)); \
|
||||
} \
|
||||
\
|
||||
inline detail::name##_type<wchar_t> \
|
||||
name(wchar_t const* s) \
|
||||
{ \
|
||||
return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(s)); \
|
||||
} \
|
||||
\
|
||||
inline detail::name##_type<char> \
|
||||
name(char c) \
|
||||
{ \
|
||||
return detail::name##_type<char>(std::basic_string<char>(1, c)); \
|
||||
} \
|
||||
\
|
||||
inline detail::name##_type<wchar_t> \
|
||||
name(wchar_t c) \
|
||||
{ \
|
||||
return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(1, c)); \
|
||||
}
|
||||
|
||||
#else // defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
|
||||
|
||||
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
|
||||
template <typename Char, typename Traits> \
|
||||
inline detail::name##_type<Char, Traits> \
|
||||
name(const std::basic_string<Char, Traits>& s) \
|
||||
{ \
|
||||
return detail::name##_type<Char, Traits>(s); \
|
||||
} \
|
||||
\
|
||||
template <typename Char> \
|
||||
inline detail::name##_type<Char> \
|
||||
name(Char s[]) \
|
||||
{ \
|
||||
return detail::name##_type<Char>(std::basic_string<Char>(s)); \
|
||||
} \
|
||||
\
|
||||
template <typename Char> \
|
||||
inline detail::name##_type<Char> \
|
||||
name(Char const s[]) \
|
||||
{ \
|
||||
return detail::name##_type<Char>(std::basic_string<Char>(s)); \
|
||||
} \
|
||||
\
|
||||
template <typename Char> \
|
||||
inline detail::name##_type<Char> \
|
||||
name(Char c) \
|
||||
{ \
|
||||
return detail::name##_type<Char>(std::basic_string<Char>(1, c)); \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#define STD_TUPLE_DEFINE_MANIPULATOR(name) \
|
||||
namespace detail \
|
||||
{ \
|
||||
struct name##_tag; \
|
||||
\
|
||||
template <typename Char, typename Traits = std::char_traits<Char> > \
|
||||
struct name##_type \
|
||||
{ \
|
||||
typedef std::basic_string<Char, Traits> string_type; \
|
||||
string_type data; \
|
||||
name##_type(const string_type& d): data(d) {} \
|
||||
}; \
|
||||
\
|
||||
template <typename Stream, typename Char, typename Traits> \
|
||||
Stream& operator>>(Stream& s, const name##_type<Char,Traits>& m) \
|
||||
{ \
|
||||
string_ios_manip<name##_tag, Stream> manip(s); \
|
||||
manip.set(m.data); \
|
||||
return s; \
|
||||
} \
|
||||
\
|
||||
template <typename Stream, typename Char, typename Traits> \
|
||||
Stream& operator<<(Stream& s, const name##_type<Char,Traits>& m) \
|
||||
{ \
|
||||
string_ios_manip<name##_tag, Stream> manip(s); \
|
||||
manip.set(m.data); \
|
||||
return s; \
|
||||
} \
|
||||
} \
|
||||
|
||||
|
||||
STD_TUPLE_DEFINE_MANIPULATOR(tuple_open)
|
||||
STD_TUPLE_DEFINE_MANIPULATOR(tuple_close)
|
||||
STD_TUPLE_DEFINE_MANIPULATOR(tuple_delimiter)
|
||||
|
||||
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_open)
|
||||
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_close)
|
||||
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_delimiter)
|
||||
|
||||
#undef STD_TUPLE_DEFINE_MANIPULATOR
|
||||
#undef STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS
|
||||
#undef FUSION_STRING_OF_STREAM
|
||||
#undef FUSION_GET_CHAR_TYPE
|
||||
#undef FUSION_GET_TRAITS_TYPE
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,65 @@
|
||||
JT9 is a mode designed for amateur QSOs at MF and LF. The mode uses
|
||||
the same 72-bit structured messages as JT65. Error control coding
|
||||
(ECC) uses a strong convolutional code with constraint length K=32,
|
||||
rate r=1/2, and a zero tail, leading to an encoded message length of
|
||||
(72+31)*2 = 206 information-carrying bits. Modulation is 9-FSK: 8
|
||||
tones for data, one for synchronization. Sixteen symbol intervals are
|
||||
used for synchronization, so a transmission requires a total of 207/3
|
||||
+ 16 = 85 channel symbols. Symbol durations tsym are approximately
|
||||
(TRperiod-8)/85, where TRperiod is the T/R sequence length in seconds.
|
||||
Exact symbol lengths are chosen so that nsps, the number of samples
|
||||
per symbol (at 12000 samples per second) is a number with no prime
|
||||
factor greater than 7. This choice makes for efficient FFTs. Tone
|
||||
spacing of the 9-FSK modulation is df=1/tsym=12000/nsps, equal to the
|
||||
keying rate. The total occupied bandwidth is 9*df. The generated
|
||||
signal has continuous phase, and there are no key clicks.
|
||||
|
||||
Parameters of five JT9 sub-modes are summarized in the following
|
||||
table, along with S/N thresholds measured by simulation on an AWGN
|
||||
channel. Numbers following "JT9-" in the sub-mode names specify the
|
||||
T/R sequence length in minutes.
|
||||
|
||||
--------------------------------------------------------------------------
|
||||
Mode nsps nsps2 df tsym BW S/N* Tdec Tfree Factors
|
||||
12000 1500 (Hz) (s) (Hz) (dB) (s) (s) of nsps nfft3
|
||||
--------------------------------------------------------------------------
|
||||
JT9-1 6912 864 1.736 0.58 15.6 -26.9 52.5 7.5 2^8 3^3 2048
|
||||
JT9-2 15360 1920 0.781 1.28 7.0 -30.2 112.3 7.7 2^10 3 5 2048
|
||||
JT9-5 40960 5120 0.293 3.41 2.6 -34.4 293.6 6.4 2^13 5 6144
|
||||
JT9-10 82944 10368 0.145 6.91 1.3 -37.5 591.0 9.0 2^10 3^4 12288
|
||||
JT9-30 252000 31500 0.048 21.00 0.4 -42.3 1788.5 11.5 2^5 3^2 5^3 7 32768
|
||||
--------------------------------------------------------------------------
|
||||
* Noise power measured in a 2500 Hz bandwidth.
|
||||
NB: nfft3 might be doubled and used with a sin^2 window.
|
||||
|
||||
Transmitting
|
||||
------------
|
||||
1. Source encode the structured message to 72 bits
|
||||
2. Apply convolutional ECC (K=32, r=1/2) to yield (72+31)*2 = 206 bits
|
||||
3. Interleave to scramble the bit order
|
||||
4. Assemble 3-bit groups to make (206+1)/3 = 69 symbols
|
||||
5. Gray-code the symbol values
|
||||
6. Insert 16 sync symbols ==> 69+16=85 channel symbols, values 0-8
|
||||
|
||||
|
||||
Receiving
|
||||
---------
|
||||
1. Apply noise blanking with the timf2 method
|
||||
2. Filter to 1000 Hz bandwidth and downsample (1/8) to 1500 Hz, saving
|
||||
complex data to array c0(2,700,000).
|
||||
3. Compute spectra at half-symbol steps. Use for waterfall display
|
||||
s(22000) and save in ss(184,22000) and savg(22000) for detecting
|
||||
sync vectors.
|
||||
4. At time Tdec, find sync vectors in ss(); get approx DF or list of DFs
|
||||
5. Do full-length FFT, NFFT1=96*nsps2, zero-padded as required.
|
||||
6. For each candidate signal, do inverse FFT of length 1536 (or 3072?).
|
||||
This yields 16 complex samples per symbol; sync tone should be
|
||||
close to zero frequency.
|
||||
7. Use afc65b method to get improved values of DF, DT.
|
||||
8. Tweak freq and time offset to 0.
|
||||
9. Compute 8-bin spectra of 69 data symbols: ssym(0:7,69). Re-order the
|
||||
bins to remove Gray code.
|
||||
10. Compute soft symbols for 206 bits (bit 207 is always 0).
|
||||
11. Remove interleaving
|
||||
12. Pack bits into bytes, send to Fano decoder
|
||||
13. If Fano succeeds, remove source encoding and display user message.
|
||||
@@ -0,0 +1,54 @@
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com>
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0
|
||||
// See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
//
|
||||
// See http://boostorg.github.com/compute for more information.
|
||||
//---------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_COMPUTE_ALGORITHM_ROTATE_HPP
|
||||
#define BOOST_COMPUTE_ALGORITHM_ROTATE_HPP
|
||||
|
||||
#include <boost/compute/system.hpp>
|
||||
#include <boost/compute/algorithm/copy.hpp>
|
||||
#include <boost/compute/container/vector.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace compute {
|
||||
|
||||
/// Performs left rotation such that element at \p n_first comes to the
|
||||
/// beginning.
|
||||
///
|
||||
/// \see rotate_copy()
|
||||
template<class InputIterator>
|
||||
inline void rotate(InputIterator first,
|
||||
InputIterator n_first,
|
||||
InputIterator last,
|
||||
command_queue &queue = system::default_queue())
|
||||
{
|
||||
//Handle trivial cases
|
||||
if (n_first==first || n_first==last)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
//Handle others
|
||||
typedef typename std::iterator_traits<InputIterator>::value_type T;
|
||||
|
||||
size_t count = detail::iterator_range_size(first, n_first);
|
||||
size_t count2 = detail::iterator_range_size(first, last);
|
||||
|
||||
const context &context = queue.get_context();
|
||||
vector<T> temp(count2, context);
|
||||
::boost::compute::copy(first, last, temp.begin(), queue);
|
||||
|
||||
::boost::compute::copy(temp.begin()+count, temp.end(), first, queue);
|
||||
::boost::compute::copy(temp.begin(), temp.begin()+count, last-count, queue);
|
||||
}
|
||||
|
||||
} //end compute namespace
|
||||
} //end boost namespace
|
||||
|
||||
#endif // BOOST_COMPUTE_ALGORITHM_ROTATE_HPP
|
||||
@@ -0,0 +1,163 @@
|
||||
|
||||
make-ldpc ex-wrong-model.pchk 1000 1800 1 evenboth 3 no4cycle
|
||||
Eliminated 19 cycles of length four by moving checks within column
|
||||
make-gen ex-wrong-model.pchk ex-wrong-model.gen dense
|
||||
Number of 1s per check in Inv(A) X B is 318.6
|
||||
rand-src ex-wrong-model.src 1 800x1000
|
||||
encode ex-wrong-model.pchk ex-wrong-model.gen ex-wrong-model.src \
|
||||
ex-wrong-model.enc
|
||||
Encoded 1000 blocks, source block size 800, encoded block size 1800
|
||||
|
||||
# FIRST SET OF TESTS, TRANSMITTING THROUGH AWGN CHANNEL WITH SIGMA=0.90
|
||||
|
||||
transmit ex-wrong-model.enc ex-wrong-model.rec 1 awgn 0.90
|
||||
Transmitted 1800000 bits
|
||||
|
||||
# DECODING WITH CORRECT AWGN NOISE MODEL, SIGMA=0.90
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 0.90 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 910 valid. Average 25.8 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 90, with src errs 89, both 89
|
||||
Bit error rate (on message bits only): 6.484e-03
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=0.95
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 0.95 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 909 valid. Average 25.7 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 91, with src errs 91, both 91
|
||||
Bit error rate (on message bits only): 6.540e-03
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=0.85
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 0.85 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 900 valid. Average 27.7 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 100, with src errs 100, both 100
|
||||
Bit error rate (on message bits only): 7.604e-03
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.40
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.40 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 755 valid. Average 42.3 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 245, with src errs 245, both 245
|
||||
Bit error rate (on message bits only): 1.884e-02
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.45
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.45 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 827 valid. Average 34.7 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 173, with src errs 172, both 172
|
||||
Bit error rate (on message bits only): 1.306e-02
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.50
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.50 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 849 valid. Average 31.7 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 151, with src errs 151, both 151
|
||||
Bit error rate (on message bits only): 1.069e-02
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.55
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.55 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 855 valid. Average 32.3 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 145, with src errs 145, both 145
|
||||
Bit error rate (on message bits only): 1.022e-02
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.60
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.60 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 790 valid. Average 40.0 iterations, 13% bit changes
|
||||
Block counts: tot 1000, with chk errs 210, with src errs 210, both 210
|
||||
Bit error rate (on message bits only): 1.452e-02
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.65
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.65 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 540 valid. Average 63.3 iterations, 11% bit changes
|
||||
Block counts: tot 1000, with chk errs 460, with src errs 460, both 460
|
||||
Bit error rate (on message bits only): 3.247e-02
|
||||
|
||||
# SECOND SET OF TESTS, TRANSMITTING THROUGH AWLN CHANNEL WITH WIDTH=0.50
|
||||
|
||||
transmit ex-wrong-model.enc ex-wrong-model.rec 1 awln 0.50
|
||||
Transmitted 1800000 bits
|
||||
|
||||
# DECODING WITH CORRECT AWLN NOISE MODEL, WIDTH=0.50
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.50 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 914 valid. Average 25.1 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 86, with src errs 86, both 86
|
||||
Bit error rate (on message bits only): 6.130e-03
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.55
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.55 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 907 valid. Average 25.6 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 93, with src errs 93, both 93
|
||||
Bit error rate (on message bits only): 6.474e-03
|
||||
|
||||
# DECODING WITH AWLN NOISE MODEL, WIDTH=0.45
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awln 0.45 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 893 valid. Average 27.5 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 107, with src errs 107, both 107
|
||||
Bit error rate (on message bits only): 7.744e-03
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=0.80
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 0.80 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 702 valid. Average 44.9 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 298, with src errs 298, both 298
|
||||
Bit error rate (on message bits only): 2.245e-02
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=0.85
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 0.85 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 765 valid. Average 39.4 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 235, with src errs 235, both 235
|
||||
Bit error rate (on message bits only): 1.693e-02
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=0.90
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 0.90 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 808 valid. Average 35.7 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 192, with src errs 192, both 192
|
||||
Bit error rate (on message bits only): 1.374e-02
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=0.95
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 0.95 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 814 valid. Average 34.6 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 186, with src errs 186, both 186
|
||||
Bit error rate (on message bits only): 1.291e-02
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=1.00
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 1.00 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 808 valid. Average 35.6 iterations, 12% bit changes
|
||||
Block counts: tot 1000, with chk errs 192, with src errs 192, both 192
|
||||
Bit error rate (on message bits only): 1.320e-02
|
||||
|
||||
# DECODING WITH AWGN NOISE MODEL, SIGMA=1.05
|
||||
|
||||
decode ex-wrong-model.pchk ex-wrong-model.rec - awgn 1.05 prprp 100 \
|
||||
| verify ex-wrong-model.pchk - ex-wrong-model.gen ex-wrong-model.src
|
||||
Decoded 1000 blocks, 771 valid. Average 40.7 iterations, 11% bit changes
|
||||
Block counts: tot 1000, with chk errs 229, with src errs 228, both 228
|
||||
Bit error rate (on message bits only): 1.524e-02
|
||||
Binary file not shown.
@@ -0,0 +1,30 @@
|
||||
/*=============================================================================
|
||||
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_VALUE_OF_IMPL_05062005_0857)
|
||||
#define FUSION_VALUE_OF_IMPL_05062005_0857
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/iterator/detail/adapt_value_traits.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct filter_view_iterator_tag;
|
||||
|
||||
namespace extension
|
||||
{
|
||||
template <typename Tag>
|
||||
struct value_of_impl;
|
||||
|
||||
template <>
|
||||
struct value_of_impl<filter_view_iterator_tag>
|
||||
: detail::adapt_value_traits {};
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
|
||||
#ifndef BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED
|
||||
#define BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2001-2004
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org/libs/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
#include <boost/mpl/aux_/config/eti.hpp>
|
||||
#include <boost/mpl/aux_/is_msvc_eti_arg.hpp>
|
||||
|
||||
namespace boost { namespace mpl { namespace aux {
|
||||
|
||||
#if defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG)
|
||||
|
||||
template< bool > struct msvc_type_impl
|
||||
{
|
||||
template< typename T > struct result_
|
||||
{
|
||||
typedef typename T::type type;
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct msvc_type_impl<true>
|
||||
{
|
||||
template< typename T > struct result_
|
||||
{
|
||||
typedef result_ type;
|
||||
};
|
||||
};
|
||||
|
||||
template< typename T > struct msvc_type
|
||||
: msvc_type_impl< is_msvc_eti_arg<T>::value >
|
||||
::template result_<T>
|
||||
{
|
||||
};
|
||||
|
||||
#else // BOOST_MPL_CFG_MSVC_70_ETI_BUG
|
||||
|
||||
template< typename T > struct msvc_type
|
||||
{
|
||||
typedef typename T::type type;
|
||||
};
|
||||
|
||||
template<> struct msvc_type<int>
|
||||
{
|
||||
typedef int type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
}}}
|
||||
|
||||
#endif // BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED
|
||||
@@ -0,0 +1,43 @@
|
||||
subroutine MoonDopJPL(nyear,month,nday,uth4,lon4,lat4,RAMoon4, &
|
||||
DecMoon4,LST4,HA4,AzMoon4,ElMoon4,vr4,dist4)
|
||||
|
||||
implicit real*8 (a-h,o-z)
|
||||
real*4 uth4 !UT in hours
|
||||
real*4 lon4 !East longitude, degrees
|
||||
real*4 lat4 !Latitude, degrees
|
||||
real*4 RAMoon4 !Topocentric RA of moon, hours
|
||||
real*4 DecMoon4 !Topocentric Dec of Moon, degrees
|
||||
real*4 LST4 !Locat sidereal time, hours
|
||||
real*4 HA4 !Local Hour angle, degrees
|
||||
real*4 AzMoon4 !Topocentric Azimuth of moon, degrees
|
||||
real*4 ElMoon4 !Topocentric Elevation of moon, degrees
|
||||
real*4 vr4 !Radial velocity of moon wrt obs, km/s
|
||||
real*4 dist4 !Echo time, seconds
|
||||
|
||||
twopi=8.d0*atan(1.d0) !Define some constants
|
||||
rad=360.d0/twopi
|
||||
clight=2.99792458d5
|
||||
|
||||
call sla_CLDJ(nyear,month,nday,djutc,j)
|
||||
djutc=djutc + uth4/24.d0
|
||||
dut=-0.460d0
|
||||
|
||||
east_long=lon4/rad
|
||||
geodetic_lat=lat4/rad
|
||||
height=40.
|
||||
nspecial=0
|
||||
|
||||
call ephem(djutc,dut,east_long,geodetic_lat,height,nspecial, &
|
||||
RA,Dec,Az,El,techo,dop,fspread_1GHz,vr)
|
||||
|
||||
RAMoon4=RA
|
||||
DecMoon4=Dec
|
||||
LST4=0. !These two variables not presently used
|
||||
HA4=0.
|
||||
AzMoon4=Az*rad
|
||||
ElMoon4=El*rad
|
||||
vr4=vr
|
||||
dist4=techo
|
||||
|
||||
return
|
||||
end subroutine MoonDopJPL
|
||||
@@ -0,0 +1,70 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2013-2014 Damien Buhl
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
|
||||
#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_ATTR_FILLER_HPP
|
||||
#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_ADAPT_BASE_ATTR_FILLER_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/fusion/adapted/struct/detail/adapt_auto.hpp>
|
||||
#include <boost/fusion/adapted/struct/detail/preprocessor/is_seq.hpp>
|
||||
|
||||
#include <boost/mpl/aux_/preprocessor/token_equal.hpp>
|
||||
|
||||
#include <boost/preprocessor/config/config.hpp>
|
||||
#include <boost/preprocessor/control/iif.hpp>
|
||||
#include <boost/preprocessor/control/expr_iif.hpp>
|
||||
#include <boost/preprocessor/logical/compl.hpp>
|
||||
#include <boost/preprocessor/tuple/elem.hpp>
|
||||
#include <boost/preprocessor/seq/for_each.hpp>
|
||||
#include <boost/preprocessor/seq/push_front.hpp>
|
||||
#include <boost/preprocessor/facilities/expand.hpp>
|
||||
#include <boost/preprocessor/facilities/is_empty.hpp>
|
||||
|
||||
|
||||
#define BOOST_FUSION_ADAPT_STRUCT_FILLER_0(X, Y) \
|
||||
BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(X,Y) \
|
||||
BOOST_FUSION_ADAPT_STRUCT_FILLER_1
|
||||
|
||||
#define BOOST_FUSION_ADAPT_STRUCT_FILLER_1(X, Y) \
|
||||
BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(X,Y) \
|
||||
BOOST_FUSION_ADAPT_STRUCT_FILLER_0
|
||||
|
||||
#define BOOST_FUSION_ADAPT_STRUCT_FILLER_0_END
|
||||
#define BOOST_FUSION_ADAPT_STRUCT_FILLER_1_END
|
||||
|
||||
#define BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(X, Y) \
|
||||
BOOST_PP_IIF(BOOST_MPL_PP_TOKEN_EQUAL(auto, BOOST_PP_EXPAND(X)), \
|
||||
((1, (Y))), \
|
||||
((2, (X,Y))) \
|
||||
)
|
||||
|
||||
#define BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR_SIZE(ATTRIBUTE) \
|
||||
BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE)
|
||||
|
||||
#define BOOST_FUSION_ADAPT_STRUCT_WRAPPEDATTR(ATTRIBUTE) \
|
||||
BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)
|
||||
|
||||
|
||||
#if BOOST_PP_VARIADICS
|
||||
|
||||
# define BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER_OP(r, unused, elem) \
|
||||
BOOST_PP_IIF(BOOST_FUSION_PP_IS_SEQ(elem), \
|
||||
BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 elem ,_END), \
|
||||
BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_EMPTY(elem)), \
|
||||
BOOST_FUSION_ADAPT_STRUCT_WRAP_ATTR(auto, elem)))
|
||||
|
||||
# define BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER(VA_ARGS_SEQ) \
|
||||
BOOST_PP_SEQ_PUSH_FRONT( \
|
||||
BOOST_PP_SEQ_FOR_EACH( \
|
||||
BOOST_FUSION_ADAPT_STRUCT_ATTRIBUTES_FILLER_OP, \
|
||||
unused, VA_ARGS_SEQ), \
|
||||
(0,0))
|
||||
|
||||
#endif // BOOST_PP_VARIADICS
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,115 @@
|
||||
# Set paths
|
||||
EXE_DIR = ../../wsjtx_install
|
||||
QT_DIR = /usr/include/qt5
|
||||
INCPATH = -I${QT_DIR} -I${QT_DIR}/QtCore
|
||||
|
||||
CC = gcc
|
||||
CXX = g++
|
||||
FC = gfortran
|
||||
AR = ar cr
|
||||
MKDIR = mkdir -p
|
||||
CP = cp
|
||||
RANLIB = ranlib
|
||||
RM = rm -f
|
||||
|
||||
FFLAGS = -O3 -funroll-loops -Wall -Wno-conversion -fno-second-underscore -DUNIX
|
||||
CFLAGS = -I. -fbounds-check -fPIE
|
||||
|
||||
# Default rules
|
||||
%.o: %.c
|
||||
${CC} ${CFLAGS} -c $<
|
||||
%.o: %.f
|
||||
${FC} ${FFLAGS} -c $<
|
||||
%.o: %.F
|
||||
${FC} ${FFLAGS} -c $<
|
||||
%.o: %.f90
|
||||
${FC} ${FFLAGS} -c $<
|
||||
%.o: %.F90
|
||||
${FC} ${FFLAGS} -c $<
|
||||
|
||||
all: libjt9.a jt9sim jt9 jt9code jt65code
|
||||
|
||||
OBJS1 = astrosub.o astro0.o astro.o tm2.o sun.o moondop.o coord.o tmoonsub.o \
|
||||
fmtmsg.o geocentric.o moon2.o toxyz.o dot.o dcoord.o \
|
||||
prog_args.o options.o pctile.o graycode.o sort.o chkmsg.o \
|
||||
unpackmsg.o igray.o unpackcall.o unpackgrid.o \
|
||||
grid2k.o unpacktext.o getpfx2.o packmsg.o deg2grid.o \
|
||||
packtext.o getpfx1.o packcall.o k2grid.o packgrid.o \
|
||||
nchar.o four2a.o grid2deg.o pfxdump.o wisdom.o \
|
||||
symspec.o analytic.o db.o genjt9.o jt9fano.o \
|
||||
packbits.o unpackbits.o encode232.o interleave9.o \
|
||||
entail.o fano232.o gran.o sync9.o decjt9.o \
|
||||
fil3.o decoder.o grid2n.o n2grid.o timer.o \
|
||||
softsym.o peakdt9.o getlags.o afc9.o fchisq.o \
|
||||
twkfreq.o downsam9.o symspec2.o ipcomm.o sleep_msec.o \
|
||||
stdmsg.o sec_midn.o usleep.o azdist.o geodist.o morse.o \
|
||||
fillcom.o chkss2.o zplot9.o flat1.o flat2.o \
|
||||
jt65a.o symspec65.o flat65.o ccf65.o decode65a.o \
|
||||
filbig.o fil6521.o afc65b.o decode65b.o setup65.o \
|
||||
extract.o fchisq65.o demod64a.o chkhist.o interleave63.o ccf2.o \
|
||||
move.o indexx.o graycode65.o twkfreq65.o smo.o smo121.o \
|
||||
wrapkarn.o init_rs.o encode_rs.o decode_rs.o gen65.o fil4.o \
|
||||
flat4.o polfit.o determ.o baddata.o
|
||||
|
||||
libjt9.a: $(OBJS1)
|
||||
$(AR) libjt9.a $(OBJS1)
|
||||
$(RANLIB) libjt9.a
|
||||
|
||||
OBJS2 = jt9.o jt9a.o jt9b.o jt9c.o
|
||||
|
||||
jt9: $(OBJS2) libjt9.a
|
||||
$(CXX) -o jt9 $(OBJS2) -L. -ljt9 -lQt5Core -lfftw3f_threads -lfftw3f `$(FC) -print-file-name=libgfortran.so`
|
||||
$(MKDIR) -p $(EXE_DIR)
|
||||
$(CP) jt9 $(EXE_DIR)
|
||||
|
||||
OBJS3 = jt9sim.o
|
||||
jt9sim: $(OBJS3) libjt9.a
|
||||
$(FC) -o jt9sim $(OBJS3) -L. -ljt9
|
||||
|
||||
OBJS4 = jt9code.o
|
||||
jt9code: $(OBJS4) libjt9.a
|
||||
$(FC) -o jt9code $(OBJS4) -L. -ljt9
|
||||
$(CP) jt9code $(EXE_DIR)
|
||||
|
||||
OBJS6 = jt65code.o
|
||||
jt65code: $(OBJS6) libjt9.a
|
||||
$(FC) -o jt65code $(OBJS6) libjt9.a
|
||||
$(CP) jt65code $(EXE_DIR)
|
||||
|
||||
sync9.o: sync9.f90 jt9sync.f90
|
||||
$(FC) $(FFLAGS) -c sync9.f90
|
||||
|
||||
peakdf9.o: peakdf9.f90 jt9sync.f90
|
||||
$(FC) $(FFLAGS) -c peakdf9.f90
|
||||
|
||||
peakdt9.o: peakdt9.f90 jt9sync.f90
|
||||
$(FC) $(FFLAGS) -c peakdt9.f90
|
||||
|
||||
jt9sim.o: jt9sim.f90 jt9sync.f90
|
||||
$(FC) $(FFLAGS) -c jt9sim.f90
|
||||
|
||||
genjt9.o: genjt9.f90 jt9sync.f90
|
||||
$(FC) $(FFLAGS) -c genjt9.f90
|
||||
|
||||
redsync.o: redsync.f90 jt9sync.f90
|
||||
$(FC) $(FFLAGS) -c redsync.f90
|
||||
|
||||
ipcomm.o: ipcomm.cpp
|
||||
$(CXX) -c $(INCPATH) -fPIE ipcomm.cpp
|
||||
|
||||
sec_midn.o: sec_midn.f90
|
||||
$(FC) -c -fno-second-underscore sec_midn.f90
|
||||
|
||||
init_rs.o: init_rs.c
|
||||
$(CC) -c -DBIGSYM=1 -o init_rs.o init_rs.c
|
||||
|
||||
encode_rs.o: encode_rs.c
|
||||
$(CC) -c -DBIGSYM=1 -o encode_rs.o encode_rs.c
|
||||
|
||||
decode_rs.o: decode_rs.c
|
||||
$(CC) -c -DBIGSYM=1 -o decode_rs.o decode_rs.c
|
||||
|
||||
.PHONY : clean
|
||||
|
||||
clean:
|
||||
$(RM) *.o libjt9.a wsjtx jt9sim jt9 jt9code
|
||||
@@ -0,0 +1,310 @@
|
||||
subroutine ft8b(dd0,newdat,nfqso,ndepth,lapon,napwid,lsubtract,iaptype,icand, &
|
||||
sync0,f1,xdt,apsym,nharderrors,dmin,nbadcrc,iap,ipass,iera,message,xsnr)
|
||||
|
||||
use timer_module, only: timer
|
||||
include 'ft8_params.f90'
|
||||
parameter(NRECENT=10,NP2=2812)
|
||||
character message*22,msgsent*22
|
||||
character*12 recent_calls(NRECENT)
|
||||
real a(5)
|
||||
real s1(0:7,ND),s2(0:7,NN)
|
||||
real ps(0:7)
|
||||
real rxdata(3*ND),rxdatap(3*ND)
|
||||
real llr(3*ND),llra(3*ND),llr0(3*ND),llrap(3*ND) !Soft symbols
|
||||
real dd0(15*12000)
|
||||
integer*1 decoded(KK),apmask(3*ND),cw(3*ND)
|
||||
integer*1 msgbits(KK)
|
||||
integer apsym(KK),rr73(11),cq(28)
|
||||
integer itone(NN)
|
||||
integer icos7(0:6),ip(1)
|
||||
complex cd0(3200)
|
||||
complex ctwk(32)
|
||||
complex csymb(32)
|
||||
logical newdat,lsubtract,lapon
|
||||
data icos7/2,5,6,0,4,1,3/
|
||||
data rr73/-1,1,1,1,1,1,1,-1,1,1,-1/
|
||||
data cq/1,1,1,1,1,-1,1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1,-1,-1,1/
|
||||
|
||||
max_iterations=30
|
||||
nharderrors=-1
|
||||
fs2=12000.0/NDOWN
|
||||
dt2=1.0/fs2
|
||||
twopi=8.0*atan(1.0)
|
||||
delfbest=0.
|
||||
ibest=0
|
||||
|
||||
call timer('ft8_down',0)
|
||||
call ft8_downsample(dd0,newdat,f1,cd0) !Mix f1 to baseband and downsample
|
||||
call timer('ft8_down',1)
|
||||
|
||||
i0=nint((xdt+0.5)*fs2) !Initial guess for start of signal
|
||||
smax=0.0
|
||||
do idt=i0-8,i0+8 !Search over +/- one quarter symbol
|
||||
call sync8d(cd0,idt,ctwk,0,sync)
|
||||
if(sync.gt.smax) then
|
||||
smax=sync
|
||||
ibest=idt
|
||||
endif
|
||||
enddo
|
||||
xdt2=ibest*dt2 !Improved estimate for DT
|
||||
|
||||
! Now peak up in frequency
|
||||
i0=nint(xdt2*fs2)
|
||||
smax=0.0
|
||||
do ifr=-5,5 !Search over +/- 2.5 Hz
|
||||
delf=ifr*0.5
|
||||
dphi=twopi*delf*dt2
|
||||
phi=0.0
|
||||
do i=1,32
|
||||
ctwk(i)=cmplx(cos(phi),sin(phi))
|
||||
phi=mod(phi+dphi,twopi)
|
||||
enddo
|
||||
call sync8d(cd0,i0,ctwk,1,sync)
|
||||
if( sync .gt. smax ) then
|
||||
smax=sync
|
||||
delfbest=delf
|
||||
endif
|
||||
enddo
|
||||
a=0.0
|
||||
a(1)=-delfbest
|
||||
call twkfreq1(cd0,NP2,fs2,a,cd0)
|
||||
xdt=xdt2
|
||||
f1=f1+delfbest !Improved estimate of DF
|
||||
|
||||
call sync8d(cd0,i0,ctwk,2,sync)
|
||||
|
||||
j=0
|
||||
do k=1,NN
|
||||
i1=ibest+(k-1)*32
|
||||
csymb=cmplx(0.0,0.0)
|
||||
if( i1.ge.1 .and. i1+31 .le. NP2 ) csymb=cd0(i1:i1+31)
|
||||
call four2a(csymb,32,1,-1,1)
|
||||
s2(0:7,k)=abs(csymb(1:8))
|
||||
enddo
|
||||
|
||||
! sync quality check
|
||||
is1=0
|
||||
is2=0
|
||||
is3=0
|
||||
do k=1,7
|
||||
ip=maxloc(s2(:,k))
|
||||
if(icos7(k-1).eq.(ip(1)-1)) is1=is1+1
|
||||
ip=maxloc(s2(:,k+36))
|
||||
if(icos7(k-1).eq.(ip(1)-1)) is2=is2+1
|
||||
ip=maxloc(s2(:,k+72))
|
||||
if(icos7(k-1).eq.(ip(1)-1)) is3=is3+1
|
||||
enddo
|
||||
! hard sync sum - max is 21
|
||||
nsync=is1+is2+is3
|
||||
if(nsync .le. 6) then ! bail out
|
||||
nbadcrc=1
|
||||
return
|
||||
endif
|
||||
|
||||
j=0
|
||||
do k=1,NN
|
||||
if(k.le.7) cycle
|
||||
if(k.ge.37 .and. k.le.43) cycle
|
||||
if(k.gt.72) cycle
|
||||
j=j+1
|
||||
s1(0:7,j)=s2(0:7,k)
|
||||
enddo
|
||||
|
||||
do j=1,ND
|
||||
ps=s1(0:7,j)
|
||||
where (ps.gt.0.0) ps=log(ps)
|
||||
r1=max(ps(1),ps(3),ps(5),ps(7))-max(ps(0),ps(2),ps(4),ps(6))
|
||||
r2=max(ps(2),ps(3),ps(6),ps(7))-max(ps(0),ps(1),ps(4),ps(5))
|
||||
r4=max(ps(4),ps(5),ps(6),ps(7))-max(ps(0),ps(1),ps(2),ps(3))
|
||||
i4=3*j-2
|
||||
i2=3*j-1
|
||||
i1=3*j
|
||||
rxdata(i4)=r4
|
||||
rxdata(i2)=r2
|
||||
rxdata(i1)=r1
|
||||
rxdatap(i4)=r4
|
||||
rxdatap(i2)=r2
|
||||
rxdatap(i1)=r1
|
||||
! When bits 88:115 are set as ap bits, bit 115 lives in symbol 39 along
|
||||
! with no-ap bits 116 and 117. Take care of metrics for bits 116 and 117.
|
||||
! if(j.eq.39) then ! take care of bits that live in symbol 39
|
||||
! if(apsym(28).lt.0) then
|
||||
! rxdatap(i2)=max(ps(2),ps(3))-max(ps(0),ps(1))
|
||||
! rxdatap(i1)=max(ps(1),ps(3))-max(ps(0),ps(2))
|
||||
! else
|
||||
! rxdatap(i2)=max(ps(6),ps(7))-max(ps(4),ps(5))
|
||||
! rxdatap(i1)=max(ps(5),ps(7))-max(ps(4),ps(6))
|
||||
! endif
|
||||
! endif
|
||||
! When bits 116:143 are set as ap bits, bit 115 lives in symbol 39 along
|
||||
! with ap bits 116 and 117. Take care of metric for bit 115.
|
||||
if(j.eq.39) then ! take care of bit 115
|
||||
iii=2*(apsym(29)+1)/2 + (apsym(30)+1)/2 ! known values of bits 116 & 117
|
||||
if(iii.eq.0) rxdatap(i4)=ps(4)-ps(0)
|
||||
if(iii.eq.1) rxdatap(i4)=ps(5)-ps(1)
|
||||
if(iii.eq.2) rxdatap(i4)=ps(6)-ps(2)
|
||||
if(iii.eq.3) rxdatap(i4)=ps(7)-ps(3)
|
||||
endif
|
||||
! bit 144 lives in symbol 48 and will be 1 if it is set as an ap bit.
|
||||
! take care of metrics for bits 142 and 143
|
||||
if(j.eq.48) then ! bit 144 is always 1
|
||||
rxdatap(i4)=max(ps(5),ps(7))-max(ps(1),ps(3))
|
||||
rxdatap(i2)=max(ps(3),ps(7))-max(ps(1),ps(5))
|
||||
endif
|
||||
! bit 154 lives in symbol 52 and will be 0 if it is set as an ap bit
|
||||
! take care of metrics for bits 155 and 156
|
||||
if(j.eq.52) then ! bit 154 will be 0 if it is set as an ap bit.
|
||||
rxdatap(i2)=max(ps(2),ps(3))-max(ps(0),ps(1))
|
||||
rxdatap(i1)=max(ps(1),ps(3))-max(ps(0),ps(2))
|
||||
endif
|
||||
enddo
|
||||
|
||||
rxav=sum(rxdata)/(3.0*ND)
|
||||
rx2av=sum(rxdata*rxdata)/(3.0*ND)
|
||||
var=rx2av-rxav*rxav
|
||||
if( var .gt. 0.0 ) then
|
||||
rxsig=sqrt(var)
|
||||
else
|
||||
rxsig=sqrt(rx2av)
|
||||
endif
|
||||
rxdata=rxdata/rxsig
|
||||
! Let's just assume that rxsig is OK for rxdatap too...
|
||||
rxdatap=rxdatap/rxsig
|
||||
|
||||
ss=0.84
|
||||
llr0=2.0*rxdata/(ss*ss)
|
||||
llra=2.0*rxdatap/(ss*ss) ! llr's for use with ap
|
||||
apmag=4.0
|
||||
! If DxCall exists, only do "MyCall DxCall ???" for candidates within nfqso +/- napwid
|
||||
nap=0
|
||||
if(lapon.and.(iaptype.eq.1 .or. (iaptype.eq.2.and.abs(nfqso-f1).le.napwid))) nap=2
|
||||
if(lapon.and.iaptype.eq.2.and.abs(nfqso-f1).gt.napwid) nap=1
|
||||
|
||||
do iap=0,nap
|
||||
nera=1
|
||||
if(iap.eq.0) nera=3
|
||||
do iera=1,nera
|
||||
llr=llr0
|
||||
nblank=0
|
||||
if(nera.eq.3 .and. iera.eq.1) nblank=0
|
||||
if(nera.eq.3 .and. iera.eq.2) nblank=24
|
||||
if(nera.eq.3 .and. iera.eq.3) nblank=48
|
||||
if(nblank.gt.0) llr(1:nblank)=0.
|
||||
if(iap.eq.0) then
|
||||
apmask=0
|
||||
! apmask(160:162)=1
|
||||
llrap=llr
|
||||
! llrap(160:162)=apmag*apsym(73:75)/ss
|
||||
endif
|
||||
if(iaptype.eq.1) then
|
||||
if(iap.eq.1) then ! look for plain CQ
|
||||
apmask=0
|
||||
apmask(88:115)=1 ! plain CQ
|
||||
apmask(144)=1 ! not free text
|
||||
! apmask(160:162)=1 ! 3 extra bits
|
||||
llrap=llr
|
||||
llrap(88:115)=apmag*cq/ss
|
||||
llrap(116:117)=llra(116:117)
|
||||
llrap(142:143)=llra(142:143)
|
||||
llrap(144)=-apmag/ss
|
||||
! llrap(160:162)=apmag*apsym(73:75)/ss
|
||||
endif
|
||||
if(iap.eq.2) then ! look for mycall
|
||||
apmask=0
|
||||
apmask(88:115)=1 ! mycall
|
||||
apmask(144)=1 ! not free text
|
||||
! apmask(160:162)=1 ! 3 extra bits
|
||||
llrap=llr
|
||||
llrap(88:115)=apmag*apsym(1:28)/ss
|
||||
llrap(116:117)=llra(116:117)
|
||||
llrap(142:143)=llra(142:143)
|
||||
llrap(144)=-apmag/ss
|
||||
! llrap(160:162)=apmag*apsym(73:75)/ss
|
||||
endif
|
||||
endif
|
||||
if(iaptype.eq.2) then
|
||||
if(iap.eq.1) then ! look for dxcall
|
||||
apmask=0
|
||||
! apmask(88:115)=1 ! mycall
|
||||
apmask(116:143)=1 ! hiscall
|
||||
apmask(144)=1 ! not free text
|
||||
! apmask(160:162)=1 ! 3 extra bits
|
||||
llrap=llr
|
||||
! llrap(88:143)=apmag*apsym(1:56)/ss
|
||||
llrap(115)=llra(115)
|
||||
llrap(116:143)=apmag*apsym(29:56)/ss
|
||||
llrap(144)=-apmag/ss
|
||||
! llrap(160:162)=apmag*apsym(73:75)/ss
|
||||
endif
|
||||
if(iap.eq.2) then ! look mycall, dxcall
|
||||
apmask=0
|
||||
apmask(88:115)=1 ! mycall
|
||||
apmask(116:143)=1 ! hiscall
|
||||
apmask(144)=1 ! not free text
|
||||
! apmask(144:154)=1 ! RRR or 73
|
||||
! apmask(160:162)=1 ! 3 extra bits
|
||||
llrap=llr
|
||||
llrap(88:143)=apmag*apsym(1:56)/ss
|
||||
llrap(144)=-apmag/ss
|
||||
! llrap(144:154)=apmag*rr73/ss
|
||||
! llrap(155:156)=llra(155:156)
|
||||
! llrap(160:162)=apmag*apsym(73:75)/ss
|
||||
endif
|
||||
endif
|
||||
|
||||
cw=0
|
||||
call timer('bpd174 ',0)
|
||||
call bpdecode174(llrap,apmask,max_iterations,decoded,cw,nharderrors, &
|
||||
niterations)
|
||||
call timer('bpd174 ',1)
|
||||
dmin=0.0
|
||||
if(ndepth.eq.3 .and. nharderrors.lt.0) then
|
||||
norder=1
|
||||
if(abs(nfqso-f1).le.napwid) then
|
||||
if(iap.eq.0) then
|
||||
norder=2
|
||||
else
|
||||
norder=3
|
||||
endif
|
||||
endif
|
||||
call timer('osd174 ',0)
|
||||
call osd174(llrap,apmask,norder,decoded,cw,nharderrors,dmin)
|
||||
call timer('osd174 ',1)
|
||||
endif
|
||||
nbadcrc=1
|
||||
message=' '
|
||||
xsnr=-99.0
|
||||
if(count(cw.eq.0).eq.174) cycle !Reject the all-zero codeword
|
||||
if(any(decoded(75:75).ne.0)) cycle !Reject if any of the 3 extra bits are nonzero
|
||||
if(nharderrors.ge.0 .and. nharderrors+dmin.lt.60.0 .and. &
|
||||
.not.(sync.lt.2.0 .and. nharderrors.gt.35) .and. &
|
||||
.not.(iap.gt.0 .and. nharderrors.gt.39) .and. &
|
||||
.not.(iera.ge.2 .and. nharderrors.gt.30) &
|
||||
) then
|
||||
call chkcrc12a(decoded,nbadcrc)
|
||||
else
|
||||
nharderrors=-1
|
||||
cycle
|
||||
endif
|
||||
if(nbadcrc.eq.0) then
|
||||
call extractmessage174(decoded,message,ncrcflag,recent_calls,nrecent)
|
||||
call genft8(message,msgsent,msgbits,itone)
|
||||
if(lsubtract) call subtractft8(dd0,itone,f1,xdt2)
|
||||
xsig=0.0
|
||||
xnoi=0.0
|
||||
do i=1,79
|
||||
xsig=xsig+s2(itone(i),i)**2
|
||||
ios=mod(itone(i)+4,7)
|
||||
xnoi=xnoi+s2(ios,i)**2
|
||||
enddo
|
||||
xsnr=0.001
|
||||
if(xnoi.gt.0 .and. xnoi.lt.xsig) xsnr=xsig/xnoi-1.0
|
||||
xsnr=10.0*log10(xsnr)-27.0
|
||||
if(xsnr .lt. -24.0) xsnr=-24.0
|
||||
return
|
||||
endif
|
||||
enddo
|
||||
enddo
|
||||
|
||||
return
|
||||
end subroutine ft8b
|
||||
@@ -0,0 +1,176 @@
|
||||
// Boost string_algo library case_conv.hpp header file ---------------------------//
|
||||
|
||||
// Copyright Pavol Droba 2002-2003.
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org/ for updates, documentation, and revision history.
|
||||
|
||||
#ifndef BOOST_STRING_CASE_CONV_HPP
|
||||
#define BOOST_STRING_CASE_CONV_HPP
|
||||
|
||||
#include <boost/algorithm/string/config.hpp>
|
||||
#include <algorithm>
|
||||
#include <locale>
|
||||
#include <boost/iterator/transform_iterator.hpp>
|
||||
|
||||
#include <boost/range/as_literal.hpp>
|
||||
#include <boost/range/begin.hpp>
|
||||
#include <boost/range/end.hpp>
|
||||
#include <boost/range/value_type.hpp>
|
||||
|
||||
#include <boost/algorithm/string/detail/case_conv.hpp>
|
||||
|
||||
/*! \file
|
||||
Defines sequence case-conversion algorithms.
|
||||
Algorithms convert each element in the input sequence to the
|
||||
desired case using provided locales.
|
||||
*/
|
||||
|
||||
namespace boost {
|
||||
namespace algorithm {
|
||||
|
||||
// to_lower -----------------------------------------------//
|
||||
|
||||
//! Convert to lower case
|
||||
/*!
|
||||
Each element of the input sequence is converted to lower
|
||||
case. The result is a copy of the input converted to lower case.
|
||||
It is returned as a sequence or copied to the output iterator.
|
||||
|
||||
\param Output An output iterator to which the result will be copied
|
||||
\param Input An input range
|
||||
\param Loc A locale used for conversion
|
||||
\return
|
||||
An output iterator pointing just after the last inserted character or
|
||||
a copy of the input
|
||||
|
||||
\note The second variant of this function provides the strong exception-safety guarantee
|
||||
|
||||
*/
|
||||
template<typename OutputIteratorT, typename RangeT>
|
||||
inline OutputIteratorT
|
||||
to_lower_copy(
|
||||
OutputIteratorT Output,
|
||||
const RangeT& Input,
|
||||
const std::locale& Loc=std::locale())
|
||||
{
|
||||
return ::boost::algorithm::detail::transform_range_copy(
|
||||
Output,
|
||||
::boost::as_literal(Input),
|
||||
::boost::algorithm::detail::to_lowerF<
|
||||
typename range_value<RangeT>::type >(Loc));
|
||||
}
|
||||
|
||||
//! Convert to lower case
|
||||
/*!
|
||||
\overload
|
||||
*/
|
||||
template<typename SequenceT>
|
||||
inline SequenceT to_lower_copy(
|
||||
const SequenceT& Input,
|
||||
const std::locale& Loc=std::locale())
|
||||
{
|
||||
return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
|
||||
Input,
|
||||
::boost::algorithm::detail::to_lowerF<
|
||||
typename range_value<SequenceT>::type >(Loc));
|
||||
}
|
||||
|
||||
//! Convert to lower case
|
||||
/*!
|
||||
Each element of the input sequence is converted to lower
|
||||
case. The input sequence is modified in-place.
|
||||
|
||||
\param Input A range
|
||||
\param Loc a locale used for conversion
|
||||
*/
|
||||
template<typename WritableRangeT>
|
||||
inline void to_lower(
|
||||
WritableRangeT& Input,
|
||||
const std::locale& Loc=std::locale())
|
||||
{
|
||||
::boost::algorithm::detail::transform_range(
|
||||
::boost::as_literal(Input),
|
||||
::boost::algorithm::detail::to_lowerF<
|
||||
typename range_value<WritableRangeT>::type >(Loc));
|
||||
}
|
||||
|
||||
// to_upper -----------------------------------------------//
|
||||
|
||||
//! Convert to upper case
|
||||
/*!
|
||||
Each element of the input sequence is converted to upper
|
||||
case. The result is a copy of the input converted to upper case.
|
||||
It is returned as a sequence or copied to the output iterator
|
||||
|
||||
\param Output An output iterator to which the result will be copied
|
||||
\param Input An input range
|
||||
\param Loc A locale used for conversion
|
||||
\return
|
||||
An output iterator pointing just after the last inserted character or
|
||||
a copy of the input
|
||||
|
||||
\note The second variant of this function provides the strong exception-safety guarantee
|
||||
*/
|
||||
template<typename OutputIteratorT, typename RangeT>
|
||||
inline OutputIteratorT
|
||||
to_upper_copy(
|
||||
OutputIteratorT Output,
|
||||
const RangeT& Input,
|
||||
const std::locale& Loc=std::locale())
|
||||
{
|
||||
return ::boost::algorithm::detail::transform_range_copy(
|
||||
Output,
|
||||
::boost::as_literal(Input),
|
||||
::boost::algorithm::detail::to_upperF<
|
||||
typename range_value<RangeT>::type >(Loc));
|
||||
}
|
||||
|
||||
//! Convert to upper case
|
||||
/*!
|
||||
\overload
|
||||
*/
|
||||
template<typename SequenceT>
|
||||
inline SequenceT to_upper_copy(
|
||||
const SequenceT& Input,
|
||||
const std::locale& Loc=std::locale())
|
||||
{
|
||||
return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
|
||||
Input,
|
||||
::boost::algorithm::detail::to_upperF<
|
||||
typename range_value<SequenceT>::type >(Loc));
|
||||
}
|
||||
|
||||
//! Convert to upper case
|
||||
/*!
|
||||
Each element of the input sequence is converted to upper
|
||||
case. The input sequence is modified in-place.
|
||||
|
||||
\param Input An input range
|
||||
\param Loc a locale used for conversion
|
||||
*/
|
||||
template<typename WritableRangeT>
|
||||
inline void to_upper(
|
||||
WritableRangeT& Input,
|
||||
const std::locale& Loc=std::locale())
|
||||
{
|
||||
::boost::algorithm::detail::transform_range(
|
||||
::boost::as_literal(Input),
|
||||
::boost::algorithm::detail::to_upperF<
|
||||
typename range_value<WritableRangeT>::type >(Loc));
|
||||
}
|
||||
|
||||
} // namespace algorithm
|
||||
|
||||
// pull names to the boost namespace
|
||||
using algorithm::to_lower;
|
||||
using algorithm::to_lower_copy;
|
||||
using algorithm::to_upper;
|
||||
using algorithm::to_upper_copy;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_STRING_CASE_CONV_HPP
|
||||
@@ -0,0 +1,331 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename T0>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0&>
|
||||
tie(T0 & arg0)
|
||||
{
|
||||
return tuple<T0&>(
|
||||
arg0);
|
||||
}
|
||||
template <typename T0 , typename T1>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1&>
|
||||
tie(T0 & arg0 , T1 & arg1)
|
||||
{
|
||||
return tuple<T0& , T1&>(
|
||||
arg0 , arg1);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2)
|
||||
{
|
||||
return tuple<T0& , T1& , T2&>(
|
||||
arg0 , arg1 , arg2);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3&>(
|
||||
arg0 , arg1 , arg2 , arg3);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38);
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39>
|
||||
BOOST_FUSION_GPU_ENABLED
|
||||
inline tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39&>
|
||||
tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39)
|
||||
{
|
||||
return tuple<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39);
|
||||
}
|
||||
}}
|
||||
Reference in New Issue
Block a user