code:
//---------------------------------------------------------------------------//
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//

#ifndef BOOST_COMPUTE_ALGORITHM_DETAIL_SCAN_ON_GPU_HPP
#define BOOST_COMPUTE_ALGORITHM_DETAIL_SCAN_ON_GPU_HPP

#include <boost/compute/kernel.hpp>
#include <boost/compute/detail/meta_kernel.hpp>
#include <boost/compute/command_queue.hpp>
#include <boost/compute/container/vector.hpp>
#include <boost/compute/detail/iterator_range_size.hpp>
#include <boost/compute/memory/local_buffer.hpp>
#include <boost/compute/iterator/buffer_iterator.hpp>

namespace boost {
namespace compute {
namespace detail {

template<class InputIterator, class OutputIterator, class BinaryOperator>
class local_scan_kernel : public meta_kernel
{
public:
    local_scan_kernel(InputIterator first,
                      InputIterator last,
                      OutputIterator result,
                      bool exclusive,
                      BinaryOperator op)
        : meta_kernel("local_scan")
    {
        typedef typename std::iterator_traits<InputIterator>::value_type T;

        (void) last;

        bool checked = true;

        m_block_sums_arg = add_arg<T *>(memory_object::global_memory, "block_sums");
        m_scratch_arg = add_arg<T *>(memory_object::local_memory, "scratch");
        m_block_size_arg = add_arg<const cl_uint>("block_size");
        m_count_arg = add_arg<const cl_uint>("count");
        m_init_value_arg = add_arg<const T>("init");

        // work-item parameters
        *this <<
            "const uint gid = get_global_id(0);\n" <<
            "const uint lid = get_local_id(0);\n";

        // check against data size
        if(checked){
            *this <<
                "if(gid < count){\n";
        }

        // copy values from input to local memory
        if(exclusive){
            *this <<
                decl<const T>("local_init") << "= (gid == 0) ? init : 0;\n" <<
                "if(lid == 0){ scratch[lid] = local_init; }\n" <<
                "else { scratch[lid] = " << first[expr<cl_uint>("gid-1")] << "; }\n";
        }
        else{
            *this <<
                "scratch[lid] = " << first[expr<cl_uint>("gid")] << ";\n";
        }

        if(checked){
            *this <<
                "}\n"
                "else {\n" <<
                "    scratch[lid] = 0;\n" <<
                "}\n";
        }

        // wait for all threads to read from input
        *this <<
            "barrier(CLK_LOCAL_MEM_FENCE);\n";

        // perform scan
        *this <<
            "for(uint i = 1; i < block_size; i <<= 1){\n" <<
            "    " << decl<const T>("x") << " = lid >= i ? scratch[lid-i] : 0;\n" <<
            "    barrier(CLK_LOCAL_MEM_FENCE);\n" <<
            "    if(lid >= i){\n" <<
            "        scratch[lid] = " << op(var<T>("scratch[lid]"), var<T>("x")) << ";\n" <<
            "    }\n" <<
            "    barrier(CLK_LOCAL_MEM_FENCE);\n" <<
            "}\n";

        // copy results to output
        if(checked){
            *this <<
                "if(gid < count){\n";
        }

        *this <<
            result[expr<cl_uint>("gid")] << " = scratch[lid];\n";

        if(checked){
            *this << "}\n";
        }

        // store sum for the block
        if(exclusive){
            *this <<
                "if(lid == block_size - 1){\n" <<
                "    block_sums[get_group_id(0)] = " <<
                       op(first[expr<cl_uint>("gid")], var<T>("scratch[lid]")) <<
                       ";\n" <<
                "}\n";
        }
        else {
            *this <<
                "if(lid == block_size - 1){\n" <<
                "    block_sums[get_group_id(0)] = scratch[lid];\n" <<
                "}\n";
        }
    }

    size_t m_block_sums_arg;
    size_t m_scratch_arg;
    size_t m_block_size_arg;
    size_t m_count_arg;
    size_t m_init_value_arg;
};

template<class T, class BinaryOperator>
class write_scanned_output_kernel : public meta_kernel
{
public:
    write_scanned_output_kernel(BinaryOperator op)
        : meta_kernel("write_scanned_output")
    {
        bool checked = true;

        m_output_arg = add_arg<T *>(memory_object::global_memory, "output");
        m_block_sums_arg = add_arg<const T *>(memory_object::global_memory, "block_sums");
        m_count_arg = add_arg<const cl_uint>("count");

        // work-item parameters
        *this <<
            "const uint gid = get_global_id(0);\n" <<
            "const uint block_id = get_group_id(0);\n";

        // check against data size
        if(checked){
            *this << "if(gid < count){\n";
        }

        // write output
        *this <<
            "output[gid] = " <<
                op(var<T>("block_sums[block_id]"), var<T>("output[gid] ")) << ";\n";

        if(checked){
            *this << "}\n";
        }
    }

    size_t m_output_arg;
    size_t m_block_sums_arg;
    size_t m_count_arg;
};

template<class InputIterator>
inline size_t pick_scan_block_size(InputIterator first, InputIterator last)
{
    size_t count = iterator_range_size(first, last);

    if(count == 0)        { return 0; }
    else if(count <= 1)   { return 1; }
    else if(count <= 2)   { return 2; }
    else if(count <= 4)   { return 4; }
    else if(count <= 8)   { return 8; }
    else if(count <= 16)  { return 16; }
    else if(count <= 32)  { return 32; }
    else if(count <= 64)  { return 64; }
    else if(count <= 128) { return 128; }
    else                  { return 256; }
}

template<class InputIterator, class OutputIterator, class T, class BinaryOperator>
inline OutputIterator scan_impl(InputIterator first,
                                InputIterator last,
                                OutputIterator result,
                                bool exclusive,
                                T init,
                                BinaryOperator op,
                                command_queue &queue)
{
    typedef typename
        std::iterator_traits<InputIterator>::value_type
        input_type;
    typedef typename
        std::iterator_traits<InputIterator>::difference_type
        difference_type;
    typedef typename
        std::iterator_traits<OutputIterator>::value_type
        output_type;

    const context &context = queue.get_context();
    const size_t count = detail::iterator_range_size(first, last);

    size_t block_size = pick_scan_block_size(first, last);
    size_t block_count = count / block_size;

    if(block_count * block_size < count){
        block_count++;
    }

    ::boost::compute::vector<input_type> block_sums(block_count, context);

    // zero block sums
    input_type zero;
    std::memset(&zero, 0, sizeof(input_type));
    ::boost::compute::fill(block_sums.begin(), block_sums.end(), zero, queue);

    // local scan
    local_scan_kernel<InputIterator, OutputIterator, BinaryOperator>
        local_scan_kernel(first, last, result, exclusive, op);

    ::boost::compute::kernel kernel = local_scan_kernel.compile(context);
    kernel.set_arg(local_scan_kernel.m_scratch_arg, local_buffer<input_type>(block_size));
    kernel.set_arg(local_scan_kernel.m_block_sums_arg, block_sums);
    kernel.set_arg(local_scan_kernel.m_block_size_arg, static_cast<cl_uint>(block_size));
    kernel.set_arg(local_scan_kernel.m_count_arg, static_cast<cl_uint>(count));
    kernel.set_arg(local_scan_kernel.m_init_value_arg, static_cast<output_type>(init));

    queue.enqueue_1d_range_kernel(kernel,
                                  0,
                                  block_count * block_size,
                                  block_size);

    // inclusive scan block sums
    if(block_count > 1){
        scan_impl(block_sums.begin(),
                  block_sums.end(),
                  block_sums.begin(),
                  false,
                  init,
                  op,
                  queue
        );
    }

    // add block sums to each block
    if(block_count > 1){
        write_scanned_output_kernel<input_type, BinaryOperator>
            write_output_kernel(op);
        kernel = write_output_kernel.compile(context);
        kernel.set_arg(write_output_kernel.m_output_arg, result.get_buffer());
        kernel.set_arg(write_output_kernel.m_block_sums_arg, block_sums);
        kernel.set_arg(write_output_kernel.m_count_arg, static_cast<cl_uint>(count));

        queue.enqueue_1d_range_kernel(kernel,
                                      block_size,
                                      block_count * block_size,
                                      block_size);
    }

    return result + static_cast<difference_type>(count);
}

template<class InputIterator, class OutputIterator, class T, class BinaryOperator>
inline OutputIterator dispatch_scan(InputIterator first,
                                    InputIterator last,
                                    OutputIterator result,
                                    bool exclusive,
                                    T init,
                                    BinaryOperator op,
                                    command_queue &queue)
{
    return scan_impl(first, last, result, exclusive, init, op, queue);
}

template<class InputIterator, class T, class BinaryOperator>
inline InputIterator dispatch_scan(InputIterator first,
                                   InputIterator last,
                                   InputIterator result,
                                   bool exclusive,
                                   T init,
                                   BinaryOperator op,
                                   command_queue &queue)
{
    typedef typename std::iterator_traits<InputIterator>::value_type value_type;

    if(first == result){
        // scan input in-place
        const context &context = queue.get_context();

        // make a temporary copy the input
        size_t count = iterator_range_size(first, last);
        vector<value_type> tmp(count, context);
        copy(first, last, tmp.begin(), queue);

        // scan from temporary values
        return scan_impl(tmp.begin(), tmp.end(), first, exclusive, init, op, queue);
    }
    else {
        // scan input to output
        return scan_impl(first, last, result, exclusive, init, op, queue);
    }
}

template<class InputIterator, class OutputIterator, class T, class BinaryOperator>
inline OutputIterator scan_on_gpu(InputIterator first,
                                  InputIterator last,
                                  OutputIterator result,
                                  bool exclusive,
                                  T init,
                                  BinaryOperator op,
                                  command_queue &queue)
{
    if(first == last){
        return result;
    }

    return dispatch_scan(first, last, result, exclusive, init, op, queue);
}

} // end detail namespace
} // end compute namespace
} // end boost namespace

#endif // BOOST_COMPUTE_ALGORITHM_DETAIL_SCAN_ON_GPU_HPP

license: mit


code:
#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif

// extended_type_info_typeid.hpp: implementation for version that depends
// on runtime typing (rtti - typeid) but uses a user specified string
// as the portable class identifier.

// (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 <typeinfo>
#include <cstdarg>
#include <boost/assert.hpp>
#include <boost/config.hpp>

#include <boost/static_assert.hpp>
#include <boost/serialization/static_warning.hpp>
#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/type_traits/remove_const.hpp>

#include <boost/serialization/config.hpp>
#include <boost/serialization/singleton.hpp>
#include <boost/serialization/extended_type_info.hpp>
#include <boost/serialization/factory.hpp>

// hijack serialization access
#include <boost/serialization/access.hpp>

#include <boost/mpl/if.hpp>

#include <boost/config/abi_prefix.hpp> // must be the last header

#ifdef BOOST_MSVC
#  pragma warning(push)
#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
#endif

namespace boost {
namespace serialization {
namespace typeid_system {

class BOOST_SYMBOL_VISIBLE extended_type_info_typeid_0 :
    public extended_type_info
{
    virtual const char * get_debug_info() const {
        if(static_cast<const std::type_info *>(0) == m_ti)
            return static_cast<const char *>(0);
        return m_ti->name();
    }
protected:
    const std::type_info * m_ti;
    BOOST_SERIALIZATION_DECL extended_type_info_typeid_0(const char * key);
    BOOST_SERIALIZATION_DECL ~extended_type_info_typeid_0();
    BOOST_SERIALIZATION_DECL void type_register(const std::type_info & ti);
    BOOST_SERIALIZATION_DECL void type_unregister();
    BOOST_SERIALIZATION_DECL const extended_type_info *
    get_extended_type_info(const std::type_info & ti) const;
public:
    virtual BOOST_SERIALIZATION_DECL bool
    is_less_than(const extended_type_info &rhs) const;
    virtual BOOST_SERIALIZATION_DECL bool
    is_equal(const extended_type_info &rhs) const;
    const std::type_info & get_typeid() const {
        return *m_ti;
    }
};

} // typeid_system

template<class T>
class extended_type_info_typeid :
    public typeid_system::extended_type_info_typeid_0,
    public singleton<extended_type_info_typeid< T > >
{
public:
    extended_type_info_typeid() :
        typeid_system::extended_type_info_typeid_0(
            boost::serialization::guid< T >()
        )
    {
        type_register(typeid(T));
        key_register();
    }
    ~extended_type_info_typeid(){
        key_unregister();
        type_unregister();
    }
    // get the eti record for the true type of this record
    // relying upon standard type info implemenation (rtti)
    const extended_type_info *
    get_derived_extended_type_info(const T & t) const {
        // note: this implementation - based on usage of typeid (rtti)
        // only does something if the class has at least one virtual function.
        BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
        return
            typeid_system::extended_type_info_typeid_0::get_extended_type_info(
                typeid(t)
            );
    }
    const char * get_key() const {
        return boost::serialization::guid< T >();
    }
    virtual void * construct(unsigned int count, ...) const{
        // count up the arguments
        std::va_list ap;
        va_start(ap, count);
        switch(count){
        case 0:
            return factory<typename boost::remove_const< T >::type, 0>(ap);
        case 1:
            return factory<typename boost::remove_const< T >::type, 1>(ap);
        case 2:
            return factory<typename boost::remove_const< T >::type, 2>(ap);
        case 3:
            return factory<typename boost::remove_const< T >::type, 3>(ap);
        case 4:
            return factory<typename boost::remove_const< T >::type, 4>(ap);
        default:
            BOOST_ASSERT(false); // too many arguments
            // throw exception here?
            return NULL;
        }
    }
    virtual void destroy(void const * const p) const {
        boost::serialization::access::destroy(
            static_cast<T const *>(p)
        );
        //delete static_cast<T const * const>(p);
    }
};

} // namespace serialization
} // namespace boost

///////////////////////////////////////////////////////////////////////////////
// If no other implementation has been designated as default,
// use this one.  To use this implementation as the default, specify it
// before any of the other headers.
#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
    #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
    namespace boost {
    namespace serialization {
    template<class T>
    struct extended_type_info_impl {
        typedef typename
            boost::serialization::extended_type_info_typeid< T > type;
    };
    } // namespace serialization
    } // namespace boost
#endif

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas

#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP


code:
#include <QDebug>
#include <QString>
#include <QSharedMemory>
#include <QSystemSemaphore>

#include "../commons.h"

// Multiple instances: KK1D, 17 Jul 2013
QSharedMemory mem_jt9;

// Semaphore not changed, as the acquire/release calls do not
// appear to be used anywhere.
QSystemSemaphore sem_jt9("sem_jt9", 1, QSystemSemaphore::Open);

extern "C" {
  bool attach_jt9_();
  bool create_jt9_(int nsize);
  bool detach_jt9_();
  bool lock_jt9_();
  bool unlock_jt9_();
  struct jt9com * address_jt9_();
  int size_jt9_();
// Multiple instances:  wrapper for QSharedMemory::setKey()
  bool setkey_jt9_(char* mykey, int mykey_len);

  bool acquire_jt9_();
  bool release_jt9_();
}

bool attach_jt9_() {return mem_jt9.attach();}
bool create_jt9_(int nsize) {return mem_jt9.create(nsize);}
bool detach_jt9_() {return mem_jt9.detach();}
bool lock_jt9_() {return mem_jt9.lock();}
bool unlock_jt9_() {return mem_jt9.unlock();}
struct jt9com * address_jt9_() {return reinterpret_cast<struct jt9com *>(mem_jt9.data());}
int size_jt9_() {return (int)mem_jt9.size();}

// Multiple instances:
bool setkey_jt9_(char* mykey, int mykey_len) {
   char *tempstr = (char *)calloc(mykey_len+1,1);
   memset(tempstr, 0, mykey_len+1);
   strncpy(tempstr, mykey, mykey_len);
   QString s1 = QString(QLatin1String(tempstr));
   mem_jt9.setKey(s1);
   return true;}

bool acquire_jt9_() {return sem_jt9.acquire();}
bool release_jt9_() {return sem_jt9.release();}


code:
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//

// Preprocessed version of "boost/mpl/minus.hpp" header
// -- DO NOT modify by hand!

namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2

    , BOOST_MPL_AUX_NTTP_DECL(int, tag1_)  = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value
    , BOOST_MPL_AUX_NTTP_DECL(int, tag2_)  = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value
    >
struct minus_impl
    : if_c<
          ( tag1_ > tag2_ )
        , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};

/// for Digital Mars C++/compilers with no CTPS/TTP support
template<> struct minus_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        BOOST_STATIC_CONSTANT(int, value  = 0);
    };
};

template<> struct minus_impl< na,integral_c_tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        BOOST_STATIC_CONSTANT(int, value  = 0);
    };
};

template<> struct minus_impl< integral_c_tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        BOOST_STATIC_CONSTANT(int, value  = 0);
    };
};

template< typename T > struct minus_tag
    : tag< T,na >
{
};

/// forward declaration

template<
      typename BOOST_MPL_AUX_NA_PARAM(N1)
    , typename BOOST_MPL_AUX_NA_PARAM(N2)
    >
struct minus2;

template<
      typename BOOST_MPL_AUX_NA_PARAM(N1)
    , typename BOOST_MPL_AUX_NA_PARAM(N2)
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct minus

    : aux::msvc_eti_base< typename if_<

          is_na<N3>
        , minus2< N1,N2 >
        , minus<
              minus2< N1,N2 >
            , N3, N4, N5
            >
        >::type

    >

{
    BOOST_MPL_AUX_LAMBDA_SUPPORT(
          5
        , minus
        , ( N1, N2, N3, N4, N5 )
        )
};

template<
      typename N1
    , typename N2
    >
struct minus2
    : aux::msvc_eti_base< typename apply_wrap2<
          minus_impl<
              typename minus_tag<N1>::type
            , typename minus_tag<N2>::type
            >
        , N1
        , N2
        >::type >::type

{
    BOOST_MPL_AUX_LAMBDA_SUPPORT(2, minus2, (N1, N2))

};

BOOST_MPL_AUX_NA_SPEC2(2, 5, minus)

}}

namespace boost { namespace mpl {

namespace aux {
template< typename T, T n1, T n2 >
struct minus_wknd
{
    BOOST_STATIC_CONSTANT(T, value  = (n1 - n2));
    typedef integral_c< T,value > type;
};

}

template<>
struct minus_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply
        : aux::minus_wknd<
              typename aux::largest_int<
                  typename N1::value_type
                , typename N2::value_type
                >::type
            , N1::value
            , N2::value
            >::type

    {
    };
};

}}


code:
// (C) Copyright Tobias Schwinger
//
// Use modification and distribution are subject to the boost Software License,
// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).

//------------------------------------------------------------------------------

// no include guards, this file is intended for multiple inclusion

// input:  BOOST_FT_syntax     type macro to use
// input:  BOOST_FT_cc         empty or cc specifier
// input:  BOOST_FT_ell        empty or "..."
// input:  BOOST_FT_cv         empty or cv qualifiers
// input:  BOOST_FT_flags      single decimal integer encoding the flags
// output: BOOST_FT_n          number of component types (arity+1)
// output: BOOST_FT_arity      current arity
// output: BOOST_FT_type       macro that expands to the type
// output: BOOST_FT_tplargs(p) template arguments with given prefix
// output: BOOST_FT_params(p)  parameters with given prefix

# include <boost/function_types/detail/classifier_impl/arity40_1.hpp>
template< typename R , 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 , typename T40 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,41> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,42> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,43> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 , typename T43 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,44> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,45> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,46> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,47> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,48> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,49> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv);
template< typename R , 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 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49 >
typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,50> ::type
classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (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 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv);


code:
/* Copyright 2003-2013 Joaquin M Lopez Munoz.
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 * See Boost website at http://www.boost.org/
 */

#ifndef BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP
#define BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP

#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
#include <boost/detail/workaround.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <cstddef>
#include <memory>
#include <new>

namespace boost{

namespace detail{

/* Allocator adaption layer. Some stdlibs provide allocators without rebind
 * and template ctors. These facilities are simulated with the external
 * template class rebind_to and the aid of partial_std_allocator_wrapper.
 */

namespace allocator{

/* partial_std_allocator_wrapper inherits the functionality of a std
 * allocator while providing a templatized ctor and other bits missing
 * in some stdlib implementation or another.
 */

template<typename Type>
class partial_std_allocator_wrapper:public std::allocator<Type>
{
public:
  /* Oddly enough, STLport does not define std::allocator<void>::value_type
   * when configured to work without partial template specialization.
   * No harm in supplying the definition here unconditionally.
   */

  typedef Type value_type;

  partial_std_allocator_wrapper(){};

  template<typename Other>
  partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){}

  partial_std_allocator_wrapper(const std::allocator<Type>& x):
    std::allocator<Type>(x)
  {
  };

#if defined(BOOST_DINKUMWARE_STDLIB)
  /* Dinkumware guys didn't provide a means to call allocate() without
   * supplying a hint, in disagreement with the standard.
   */

  Type* allocate(std::size_t n,const void* hint=0)
  {
    std::allocator<Type>& a=*this;
    return a.allocate(n,hint);
  }
#endif

};

/* Detects whether a given allocator belongs to a defective stdlib not
 * having the required member templates.
 * Note that it does not suffice to check the Boost.Config stdlib
 * macros, as the user might have passed a custom, compliant allocator.
 * The checks also considers partial_std_allocator_wrapper to be
 * a standard defective allocator.
 */

#if defined(BOOST_NO_STD_ALLOCATOR)&&\
  (defined(BOOST_HAS_PARTIAL_STD_ALLOCATOR)||defined(BOOST_DINKUMWARE_STDLIB))

template<typename Allocator>
struct is_partial_std_allocator
{
  BOOST_STATIC_CONSTANT(bool,
    value=
      (is_same<
        std::allocator<BOOST_DEDUCED_TYPENAME Allocator::value_type>,
        Allocator
      >::value)||
      (is_same<
        partial_std_allocator_wrapper<
          BOOST_DEDUCED_TYPENAME Allocator::value_type>,
        Allocator
      >::value));
};

#else

template<typename Allocator>
struct is_partial_std_allocator
{
  BOOST_STATIC_CONSTANT(bool,value=false);
};

#endif

/* rebind operations for defective std allocators */

template<typename Allocator,typename Type>
struct partial_std_allocator_rebind_to
{
  typedef partial_std_allocator_wrapper<Type> type;
};

/* rebind operation in all other cases */

template<typename Allocator>
struct rebinder
{
  template<typename Type>
  struct result
  {
      typedef typename Allocator::BOOST_NESTED_TEMPLATE
          rebind<Type>::other other;
  };
};

template<typename Allocator,typename Type>
struct compliant_allocator_rebind_to
{
  typedef typename rebinder<Allocator>::
      BOOST_NESTED_TEMPLATE result<Type>::other type;
};

/* rebind front-end */

template<typename Allocator,typename Type>
struct rebind_to:
  mpl::eval_if_c<
    is_partial_std_allocator<Allocator>::value,
    partial_std_allocator_rebind_to<Allocator,Type>,
    compliant_allocator_rebind_to<Allocator,Type>
  >
{
};

/* allocator-independent versions of construct and destroy */

template<typename Type>
void construct(void* p,const Type& t)
{
  new (p) Type(t);
}

#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
/* MSVC++ issues spurious warnings about unreferencend formal parameters
 * in destroy<Type> when Type is a class with trivial dtor.
 */

#pragma warning(push)
#pragma warning(disable:4100)
#endif

template<typename Type>
void destroy(const Type* p)
{

#if BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590))
  const_cast<Type*>(p)->~Type();
#else
  p->~Type();
#endif

}

#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
#pragma warning(pop)
#endif

} /* namespace boost::detail::allocator */

} /* namespace boost::detail */

} /* namespace boost */

#endif


code:
#ifndef BOOST_MPL_OR_HPP_INCLUDED
#define BOOST_MPL_OR_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/aux_/config/use_preprocessed.hpp>

#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
    && !defined(BOOST_MPL_PREPROCESSING_MODE)

#   include <boost/mpl/bool.hpp>
#   include <boost/mpl/aux_/nested_type_wknd.hpp>
#   include <boost/mpl/aux_/na_spec.hpp>
#   include <boost/mpl/aux_/lambda_support.hpp>
#   include <boost/mpl/aux_/config/msvc.hpp>

// agurt, 19/may/04: workaround a conflict with <iso646.h> header's
// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(or)'
// has to be checked in a separate condition, otherwise GCC complains
// about 'or' being an alternative token
#if defined(_MSC_VER) && !defined(__clang__)
#ifndef __GCCXML__
#if defined(or)
#   pragma push_macro("or")
#   undef or
#   define or(x)
#endif
#endif
#endif

#   define BOOST_MPL_PREPROCESSED_HEADER or.hpp
#   include <boost/mpl/aux_/include_preprocessed.hpp>

#if defined(_MSC_VER) && !defined(__clang__)
#ifndef __GCCXML__
#if defined(or)
#   pragma pop_macro("or")
#endif
#endif
#endif

#else

#   define AUX778076_OP_NAME or_
#   define AUX778076_OP_VALUE1 true
#   define AUX778076_OP_VALUE2 false
#   include <boost/mpl/aux_/logical_op.hpp>

#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
#endif // BOOST_MPL_OR_HPP_INCLUDED


code:
//---------------------------------------------------------------------------//
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//

#ifndef BOOST_COMPUTE_ASYNC_FUTURE_HPP
#define BOOST_COMPUTE_ASYNC_FUTURE_HPP

#include <boost/compute/event.hpp>

namespace boost {
namespace compute {

/// \class future
/// \brief Holds the result of an asynchronous computation.
///
/// \see event, wait_list
template<class T>
class future
{
public:
    future()
        : m_event(0)
    {
    }

    future(const T &result, const event &event)
        : m_result(result),
          m_event(event)
    {
    }

    future(const future<T> &other)
        : m_result(other.m_result),
          m_event(other.m_event)
    {
    }

    future& operator=(const future<T> &other)
    {
        if(this != &other){
            m_result = other.m_result;
            m_event = other.m_event;
        }

        return *this;
    }

    ~future()
    {
    }

    /// Returns the result of the computation. This will block until
    /// the result is ready.
    T get()
    {
        wait();

        return m_result;
    }

    /// Returns \c true if the future is valid.
    bool valid() const
    {
        return m_event != 0;
    }

    /// Blocks until the computation is complete.
    void wait() const
    {
        m_event.wait();
    }

    /// Returns the underlying event object.
    event get_event() const
    {
        return m_event;
    }

private:
    T m_result;
    event m_event;
};

/// \internal_
template<>
class future<void>
{
public:
    future()
        : m_event(0)
    {
    }

    template<class T>
    future(const future<T> &other)
        : m_event(other.get_event())
    {
    }

    explicit future(const event &event)
        : m_event(event)
    {
    }

    template<class T>
    future<void> &operator=(const future<T> &other)
    {
        m_event = other.get_event();

        return *this;
    }

    future<void> &operator=(const future<void> &other)
    {
        if(this != &other){
            m_event = other.m_event;
        }

        return *this;
    }

    ~future()
    {
    }

    void get()
    {
        wait();
    }

    bool valid() const
    {
        return m_event != 0;
    }

    void wait() const
    {
        m_event.wait();
    }

    event get_event() const
    {
        return m_event;
    }

private:
    event m_event;
};

/// \internal_
template<class Result>
inline future<Result> make_future(const Result &result, const event &event)
{
    return future<Result>(result, event);
}

} // end compute namespace
} // end boost namespace

#endif // BOOST_COMPUTE_ASYNC_FUTURE_HPP


code:
// Boost.Range library
//
//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
//  distribution is subject to the Boost Software License, Version
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/range/
//

#ifndef BOOST_RANGE_EMPTY_HPP
#define BOOST_RANGE_EMPTY_HPP

#if defined(_MSC_VER)
# pragma once
#endif

#include <boost/range/config.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>

namespace boost
{

    template< class T >
    inline bool empty( const T& r )
    {
        return boost::begin( r ) == boost::end( r );
    }

} // namespace 'boost'

#endif


code:
# /* **************************************************************************
#  *                                                                          *
#  *     (C) Copyright Edward Diener 2013.
#  *     Distributed under the Boost Software License, Version 1.0. (See
#  *     accompanying file LICENSE_1_0.txt or copy at
#  *     http://www.boost.org/LICENSE_1_0.txt)
#  *                                                                          *
#  ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef BOOST_PREPROCESSOR_TUPLE_POP_FRONT_HPP
# define BOOST_PREPROCESSOR_TUPLE_POP_FRONT_HPP
#
# include <boost/preprocessor/config/config.hpp>
#
# if BOOST_PP_VARIADICS
#
# include <boost/preprocessor/array/pop_front.hpp>
# include <boost/preprocessor/array/to_tuple.hpp>
# include <boost/preprocessor/comparison/greater.hpp>
# include <boost/preprocessor/control/iif.hpp>
# include <boost/preprocessor/tuple/size.hpp>
# include <boost/preprocessor/tuple/to_array.hpp>
#
#
# /* BOOST_PP_TUPLE_POP_FRONT */
#
# define BOOST_PP_TUPLE_POP_FRONT(tuple) \
	BOOST_PP_IIF \
		( \
		BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
		BOOST_PP_TUPLE_POP_FRONT_EXEC, \
		BOOST_PP_TUPLE_POP_FRONT_RETURN \
		) \
	(tuple) \
/**/
#
# define BOOST_PP_TUPLE_POP_FRONT_EXEC(tuple) \
	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT(BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
/**/
#
# define BOOST_PP_TUPLE_POP_FRONT_RETURN(tuple) tuple
#
# /* BOOST_PP_TUPLE_POP_FRONT_Z */
#
# define BOOST_PP_TUPLE_POP_FRONT_Z(z, tuple) \
	BOOST_PP_IIF \
		( \
		BOOST_PP_GREATER(BOOST_PP_TUPLE_SIZE(tuple),1), \
		BOOST_PP_TUPLE_POP_FRONT_Z_EXEC, \
		BOOST_PP_TUPLE_POP_FRONT_Z_RETURN \
		) \
	(z, tuple) \
/**/
#
# define BOOST_PP_TUPLE_POP_FRONT_Z_EXEC(z, tuple) \
	BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_FRONT_Z(z, BOOST_PP_TUPLE_TO_ARRAY(tuple))) \
/**/
#
# define BOOST_PP_TUPLE_POP_FRONT_Z_RETURN(z, tuple) tuple
#
# endif // BOOST_PP_VARIADICS
#
# endif // BOOST_PREPROCESSOR_TUPLE_POP_FRONT_HPP


code:
			WSJT-X ChangeLog
------------------------------------------------------------------

May 30, 2013: Version 1.0, r3323
--------------------------------

With this release of WSJT-X Version 1.0 we include a few (relatively
minor) enhancements in response to user requests, as well as some
program polishing and cleanup.  Active program development will
continue, but new releases will become less frequent.

1. New option on the Setup menu: "Tx freq locked to Rx freq".

2. Double-click on a decoded "73" message now sets Tx5, rather than Tx6.

3. New keyboard shortcuts: Alt+1 through Alt+6 set the next Tx message
   at the corresponding number.

4. PTT control via Ham Radio Deluxe has been imnplemented and tested.

5. "Tool Tips" are now provided for most on-screen controls.

6. Under Linux and OS X, listings of available audio devices and APIs
   have been corrected.

7. Tab order among GUI controls has been cleaned up.

8. Updates to the WSJT-X User's Guide.

May 22, 2013: v0.99, r3297
--------------------------

1. CAT control via Ham Radio Deluxe is now available.  For setup
   details see item #5 at the top of page 6 of the updated WSJT-X
   User's Guide.

2. Submodes JT9-5, JT8-10, JT9-30 have been de-activated.  (As far as I
   know, nobody was using them.)  This action makes the program smaller
   by some 150 MB and able to run effectively on some older computers.

3. Bizarre ordering of COM port numbers on the drop-down list has been
   corrected, and suitable serial ports added to the list displayed in
   Linux.

4. Gray bar between decoding periods now contains a dashed line.

5. Corrected a bug that prevented use of Setup | Configuration with
   no existing wsjtx.ini file.

May 17, 2013: v0.95, r3278
--------------------------
1.  Double-clicking on a decoded text line in "Band Activity" window
    now copies the line into the "QSO Frequency" window if it was not
    already there.

2.  Option "Color highlighting in left window" removed from Setup
    menu.  Highlighting is now always done.

3.  Positions of "QSO Frequency" and "Band Activity" windows have been
    swapped.

4.  F4 was restored to its previous use; F5 is now used to display
    Special Mouse Commands

5.  Small square between Band selector and Frequency readout was made
    a control button.  Orange indicates one-way CAT control from
    program to radio, red indicates bi-directional control.  Clicking
    the orange button causes a one-time readout of dial frequency.

6.  If Save=None, the last recorded file is deleted on program exit.
    This prevents unwanted accumulation of files in the Save
    directory.

7.  Status-bar messages were re-arranged in a more logical order.

8.  Tx signal report was added to wsjtx_status.txt (for JT-Alert)

9.  More informative labels were placed on the "Tab 2" GUI controls.

10. Better default scaling for the "Cumulative" spectrum.

11. New algorithm for identifying JT9 signals to send to decoder,
    resulting major improvements in decoder speed.

12. Bug fixes:
     - Incorrect displayed frequencies for JT9-2 signals
     - Infinitely repeated "Error rigOpen -1" messages
     - User tries to open CAT control using busy or nonexistent serial port

13. Many updates to the User's Guide

May 2, 2013: v0.95, r3251
-------------------------

1. The "band change" function is executed whenever the Band combobox
   is activated, even if the selected band has not changed.

2. The program does not set rig mode.  That task is left to the user.

3. Time interval for polling rig frequency is now a user parameter on
   the setup screen.  I set mine to 1 second, which works fine with
   the Kenwood TS-2000.  Set it to 0 if you want no polling for
   frequency (which means unidirectional CAT control from program to
   radio).  Choose something like 10 s for the K3.

4. Much new work on the WSJT-X User's Guide, which is approaching its
   final form for Version 1.0.  Please read it and tell us about
   anything you find unclear or missing!

These changes address nearly all of the CAT issues found by a few
users -- those with K3, IC-746, IC-706, in particular.

One additional piece of advice when running WSJT-X in Windows: connect
and turn on the radio and any interface equipment before starting
WSJT-X, and exit the program before turning such equipment off.

April 29, 2013: v0.95, r3243
----------------------------

1. Now has bi-directionsl CAT control using direct calls to hamlib
   functions.  Highlights displayed dial frequency with red background
   if frequency differs from nominal for the selected band by more
   than 100 kHz.  (Is there a more useful or logical condition to
   flag?)  Small red square between Band selector and Dial Frequency
   display to indicate that CAT control is active.  Mode is set to USB
   on startup.  (Note: CAT control diagnostics are presently rather
   rudimentary, we're still working on this.  Feedback is welcome!)

2. New controls on Setup | Configuration screen:
   - RTS/DTR OFF -- needed by K2 and maybe other radios
   - Data / Mic -- select CAT-control PTT type
   - Test CAT Control -- try settings before returning to main screen
   - Test PTT -- try settings for toggling PTT On/Off

3. Help menu now provides displays of Keyboard Shortcuts (quick access
   via F3) and Special Mouse Commands (F4).

4. Option "Setup | Advanced | Allow multiple instances" enables the
   use of more than one instance of WSJT-X for special applications.
   (The program must be copied into and run from different
   directories.)

5. No posts to PSK Reporter if band was changed during the reception
   period.

6. Improved behavior of Tune button.

7. Improved inter-process communication between WSJT-X and JT-Alert-X.

8. Better interaction between "Report" spinner control and Tx messages.

9. Removed the NB checkbox and slider.  (Has anyone found these useful?)

10. New buttons on main window: "Tx=Rx" sets Tx frequency to current
    Rx frequency; "Rx=Tx" does the opposite.

11. Log QSO confirmation window is now "non-modal": you can keep it
    open and still access controls on the main window.

12. Tab-order has been rationalized on most screens.

13. Dial frequency and mode written to file ALL.TXT.

14. Double-click on decoded line sets Tx message #3 if message has
     the form "MyCall Call2 rpt".

15. Bug causing occasional, seemingly unpredictable program crashes
    has been fixed.

16. The WSJT-X User's Guide is somewhat closer to being complete.  User
    feedback on the Guide will be most welcome.  What is unclear?  What
    is missing?

April 17, 2013: v0.9, r3195
---------------------------
1. Sorry, the CAT control changes in r3187/3188 were a dismal failure
in many stations, and they introduced other bugs as well.  This revision
goes back to uni-directional CAT control: the program can set the
radio's dial frequency and do T/R switching, but that's all.  The band
setting is not reset on program startup.

2. Logic for the Tune button has been corrected.

3. For Linux compile-it-yourself enthusiasts: the interface to
PSK Reporter is now working undel Linux.

April 16, 2013: v0.9, r3188
---------------------------

1. CAT control now reads and follows changes in radio's dial
frequency.  Readout gets red highlighting if radio is on wrong band.
On program restart, band is reset to the last selected band.

2. New "Tune" button generates an unmodulated carrier.  Toggle button
a second time to turn Tx off.

3. Added labels at top of "Tab 2" and enlarged the text entry fields.

4. Fixed the broken logic for "Runaway Tx watchdog".

5. Fixed "Prompt me to log QSO" so that it no longer requires also
setting "ID after 73".

6. Additional changes of (eventual) interest to Linux users.  Code for
sending spots to PSK Reporter now in place.

April 13, 2013: v0.9, r3166
---------------------------
1. Option to send Tx messages (highlighted in yellow) to the QSO window.

2. Prevent starting a transmission more than 24 sec into a Tx period.

3. "Setup | Options" changed to "Setup | Configuration".

4. Type Alt-V to save the most recently completed Rx file.

5. Fixed bug that truncated Rx messages to 16 characters.

6. Internal program changes that should provide better user diagnostics
when necessary at program startup.

April 11, 2013: v0.9, r3157
---------------------------
1. Maximum size of several window areas increased to accommodate system
fonts set larger than default.

2. New behavior of Erase button: click once to erase the left (QSO) window,
twice to erase both decoded text windows.

3. Keyboard shortcuts:
   Alt-D: decode again at QSO frequency (same as clicking the Decode() button)
   Shift-D: do another full decode in both windows
   Alt-E: Erase()
   Ctrl-F: Edit the free text message box
   Alt-H: Halt Tx()
   Alt M: Monitor()
   Alt-N: Enable Tx()
   Alt-Q: Log QSO()
   Alt-S: Stop()

4. New Setup options: "Tx disabled after sending 73" and "Runaway Tx
watchdog".

5. Fixed bug in saving the "report received" for logging purposes.

6. Corrected the logic for "Runaway Tx watchdog".

7. Fixed bug that truncated characters 17 and 18 of decoded messages.

April 10, 2013: v0.9, r3151
---------------------------
1. Blank line between decoding periods is now in the right-hand
text window, where it should be.
2. Decoding range defined by fMin and fMax is now enforced.

April 9, 2013: v0.9, r3143
--------------------------
This minor release restores the decoding speed of earlier revisions
and corrects a bug that prevented sending CW ID.

April 9, 2013: v0.9, r3142
--------------------------

This version of WSJT-X has a number of significant changes.  Please
read the following notes carefully.  Also -- even if you are already
familiar with WSJT-X -- be sure to read the updated WSJT-X User's
Guide at
http://www.physics.princeton.edu/pulsar/K1JT/WSJT-X_Users_Guide.pdf ,
especially pages 3 and 4.

Changes since v0.8 r3118 include the following:

1. There are now two scrolling windows for decoded text.  The left
window contains decodes only from close to the designated QSO
frequency.  The right window includes signals over the full decoding
range.

2. An alternative set of controls is now available for generating and
selecting Tx messages.  Some may find these more convenient to use
than the Tx1 through Tx6 message boxes.

3. A number of new user options are available on the Setup menu:
   - Blank line between decoding periods (right window only)
   - Clear DX Call and DX Grid after logging QSO
   - Display distances in miles
   - Runaway Tx watchdog
   - Background colors for left window
   - Double-click on decoded message sets Tx Enable

4. New or changed on-screen features
   - "Tol" replaced by fMin and fMax on waterfall screen (see User's Guide)
   - Spinner control for signal report
   - On waterfall scale: green marker for Rx freq, red for Tx. blue
     for decoding range

5. New behavior
   - "CQ DX" is now treated properly when decoded line is double-clicked
   - Message formate for compound callsigns (e.g., PJ4/K1ABC, G4XYZ/P)
     are now handled correctly.  (Some restrictions apply, and will
     be spelled out in the completed User's Guide.)
   - Decode button now causes a decode only at the specified Rx frequency.
   - Click on waterfall spectrum sets Rx freq; double-click also invokes
     decoder (as though Decode button had been clicked).  CTRL-click moves
     both Rx and Tx freqs.
   - Amplitude at end of transmission is ramped down to prevent a final
     key click.

6. The following bugs have been fixed:
   - Logic error in decoder
   - Certain non-standard Tx messages could cause a program crash.
   - Certain (rarely used) messages did not pack/unpack correctly

April 2, 2013: v0.8, r3118
--------------------------
1. Improved interface to program JT-Alert, by VK3AMA.

2. The LogQSO confirmation dialog no longer blocks the GUI updating
   process.

3. A blank line with gray background separates the decoded text lines for
   each new invocation of the decoder.

4. New suggested default frequencies: 5.357, 18.104, and 24.918 MHz.
   Be sure to edit these entries on the 'Default Frequencies' tab of the
   Setup screen.  (When you have done this once, the new values will be
   remembered.)

5. The LogQSO button now does nothing is the 'DX call' entry field is
   blank.

6. Several minor bugs were fixed.

March 27, 2013: v0.8, r3113
---------------------------
1. Bug fix: VOX control of T/R switching now works.

2. Potentially useful error messages now appear when CAT control
   has failed.

3. Added an instruction on the Log QSO confirmation screen.

4. Clear the DXcall and DXgrid entries after logging a QSO.

March 26, 2013: v0.8, r3112
---------------------------

Edson Pereira, PY2SDR, recently became an active contributor to this
open-source project.  Edson and I have been very busy over the past
few days!  WSJT-X revision 3112 has many changes and new features.

1. The GUI layout has been adjusted and optimized.

2. CAT control is now operational, offering optional control of your
   radio's dial frequency and T/R status.  Go to the Setup | Options
   window to select the necessary parameters.

3. CW ID has been implemented.  You can have your ID sent after a fixed
   time interval, or automatically when you transmit a "73" or free
   text message.

4. Default dial frequencies are available for each band on a new tab
   on the Setup | Options window.  Please note: some of these
   frequencies are probably wrong!  You can edit them as needed.
   (Please let us know if the original values are inconsistent with
   actual practice on any band.)

5. Several new options appear on the Setup menu.  Try them!

6. Azimuth and Distance information is displayed whenever a valid grid
   locator appears in the "Dx Grid" box.

7. The decoder has again been adjusted for better compromise between
   sensitivity and decoding time.

8. The User's Guide is out of date, and needs work.  We hope to get to
   that task soon.

9. Very important for some would-be users: WSJT-X now runs properly
   under Linux.  We haven't made a package yet, so for now you must
   compile your own.  If you don't know how, we hope to be set up
   to make packages before too long.

10. If you know someone who might be interested in contributing to the
    development of WSJT-X and related projects, please send him/her
    our way!  We're especially looking for someone interested in
    producing packaged Linux distributions -- for example, *.deb or
    *.rpm packages, but other programming help is also wanted.

As always: please report bugs, and don't be bashful about sending us
your feature requests!

March 22, 2013: v0.7, r3071
---------------------------
1. Correct a bug that (still) allowed display of previous decodes
when nothing new was decoded.

2. Add a user confirmation screen activated when you click Log QSO.
This lets you edit or add information before it is written to the
ADIF file.

3. Tx message macros and now available.  Configure them on the Setup
window.  They are invoked as a pop-up menu by right-clicking on the
Tx5 message window; then select the desired message by left-clicking
on the desired message.

March 20, 2013: v0.7, r3063
---------------------------
1. Add Frequency to the generated ADIF records.

2. Correct a decoder bug that led to duplication of previous output
when nothing new was decoded.

March 19, 2013: v0.7, r3061
---------------------------
1. Allow Windows COM port numbers up to 99.

2. Replace status files wsjtx_qrg.txt and wsjtx_txcall.txt with
a single file, wsjtx_status.txt.

3. Combine wsjtx_rx.log and wsjtx_tx.log into a single file ALL.TXT.

4. "Log QSO" now writes a file in ADIF format.

5. Starting to implement popup macros for Tx message #5.

6. Big improvement in decoding speed.

*** More changes to come!  Please report any problems, especially
*** with the ADIF-format log.

March 12, 2013: v0.6, r3046
---------------------------
1. Decoded calls can now be uploaded to the PSK Reporter web site.
Check the box "Enable PSK Reporter" on the Setup screen, and go to
http://pskreporter.info/pskmap.html to see the spots.  Be sure to
enter your "Dial Frequency (MHz)" at lower right of the Wide Graph
window.  (Rig control features are yet to come...)

2. Added some interfaces to permit use with the program JT-Alert,
by VK3AMA.  Look for this capability in the near future.

March 6, 2013: v0.5, r3038
--------------------------
1. Selection of Current/Cumulative/JT9Sync for the 2d spectral display
changed to a combobox.

2. Double-click on decoded text does not change frequency settings
if first decoded call is MyCall.

March 1, 2013: v0.5, r3026
--------------------------
1. The horizontal scale of 2d spectra (e.g., the "red curve") is now
correct when the user has selected FFT Bins/Pixel > 1.

2. Double-clicking on a decoded text line now selects the second
callsign independent of exactly where one has clicked on the line.
In addition, it sets the selected frequencies (both Tx and Rx) to
the frequency of the decoded transmission.

December 11, 2012: v0.5, r2791
------------------------------
1. Messages of the form "CQ DX K1ABC" are now supported.

November 30, 2012: v0.5, r2788
------------------------------
1. A bug was introduced when support for positive signal reports was
added.  It could cause a program crash when certain free-text messages
were composed for transmission.  The bug has been fixed.

2. In the slower JT9 sub-modes, the UTC listed on decoded text lines
has been changed to the start time of the Rx sequence, rather than the
time of the final minute.

3. The waterfall's "Auto Zero" button had no function, and has been
removed.

4. In previous revisions the installer put a number of DLLs into
the Windows system directory, normally C:\Windows\System32.  This
revision installs the DLLs to the WSJT-X installation directory.

November 29, 2012: v0.5, r2786
------------------------------
1. In r2783, the companion program jt9.exe (started automatically when
you start WSJT-X) was a CPU hog for no good reason.  This was an
oversight on my part, and the bug has been corrected.

2. The program should now run correctly if installed in a directory
whose name contains embedded spaces.  (Under Vista and Win7, however,
it's still not a good idea to install WSJT-X into C:\Program Files,
because of restricted write permissions there.)

3. In r2783 and earlier, stopping a transmission by toggling to "Auto
OFF" would terminate Tx audio and release PTT almost simultaneously,
possibly hot-switching your T/R relay(s).  This has been corrected so
that proper sequencing takes place.

November 28, 2012: v0.5, r2783
------------------------------
This revision has an unusually large number of changes relative to the
previous release, v0.4 r2746.  These changes include:

1. PTT control via COM ports COM10 and higher is enabled.

2. Improved decoder performance: higher speed as well as better
chances of success.  Moderate amounts of frequency drift are detected
and compensated.  Computed S/N values are more reliable.  Time offsets
from -2.5 to +5 s are now supported, which makes JT9 usable for EME.
(EME tests on 144 MHz have been successful, and performance on that
propagation mode appears to be good.)

3. Tx Frequency now tracks the selected QSO Frequency (unless you hold
down the CTRL key when setting QSO Frequency via mouse-clicks or the
F11/F12 keys).

4. Decoded text containing "CQ " is highlighted with green background;
text including "MyCall" is highlighted in red.

5. In previous versions, signal reports were required to be in the
range -30 to -01 dB.  In v0.5 r2782 the range has been extended to -50
to +49 dB.  There is backward compatibility for the range -30 to -01,
but reports in the range -50 to -31 and 0 to +49 will NOT be decoded
correctly by previous program versions.  It is important to upgrade!

6. Items "Save Synced" and "Save Decoded" are now implemented.

7. UTC Date, JT9 submode, and a parameter related to the decoding
procedure are now included in file wsjtx_rx.log.

8. Editing of Tx messages (in any of the six Tx message boxes) is
complete when you hit "Tab" or "Return".  The message is then parsed
and converted to the form in which it will be displayed if decoding is
successful.  Free-text messages are trimmed to 13 characters and
highlighted with a pink background.

9. The most recent transmitted message is displayed in the right-most
label on the status bar.  This can be useful if you have lost track of
where you were in a QSO.

10. By default, the program now starts with Monitor ON.  An option on
the Setup menu allows you to select "Monitor OFF at startup".

11. Better scaling is provided for the red "JT9 Sync" curve.  Note
that JT9 signals in the active sub-mode should appear in this plot as
a bump of width equal to the total signal bandwidth, with a narrow and
slightly higher bump at the left edge.  The narrow bump is the
frequency of the Sync tone, which is defined as the nominal frequency
of the JT9 signal.

12. Basic QSO information is now written to file wsjt.log when you
click the "Log QSO" button.

13. The WSJT-X User's Guide has been updated.

14. Other known bugs have been fixed.  There will probably be new
ones!  When you find one, or if you know of any old ones that have NOT
been fixed, please send me email.

Summary of Present Status
----------------------------------------------------------------------
I believe that WSJT-X is now a stable and very usable program.  Many
thousands of QSOs have been made with JT9-1, mostly at HF -- I have
made nearly 100, myself.  Also a number of QSOs have also been
completed at MF, and successful tests have been made on 2m EME, etc.
A number of QSOs have also been made with JT9-2.

As far as I know the slower modes (JT9-5, JT9-10, and JT9-30) also
work correctly.  (Certainly they do in my laboratory test setup.)
Most people will find these modes too slow for "everyday" use, and
they require high frequency stability.  It remains to be seen whether
they will be widely used.

An alternative approach to obtaining improved sensitivity would be to
give the decoder an ability to average over several successive
transmissions.  For example, the average of five JT9-1 transmissions
could reach a decoding threshold around -32 dB, only 2 dB worse than a
single JT9-5 transmission.  Because of QSB, the shorter transmissions
may actually succeed in less total time.  Stability requirements would
be those of JT9-1, much less stringent than those of JT9-5.

Program development is not finished, by any means.  I will be grateful
for your feedback on performance issues, as well as your "wish-list"
of features to be added.  As always, example recordings of files that
you think should have decoded, but did not, will be much appreciated.

November 16, 2012: v0.4, r2746
------------------------------

Changes from v0.4 r2731 include the following:

1. Valid signal reports are now generated by double-clicking on a
callsign in the decoded text window.

2. Consecutive spaces in a Tx message are now collapsed into a single
space.

3. Decoding speed is much improved, especially when strong (possibly
non-JT9) signals are present and "Tol" is set to a relatively large
value.

4. Scaling of the "JT9 Sync" plot (red curve) is more reasonable.

5. Layout of widgets on the main window has been improved.

6. Several minor bug fixes.

November 14, 2012: v0.4, r2731
------------------------------

A number of known bugs have been fixed, and the JT9 decoder is
significantly improved.  Among other improvements, the program is now
much less fussy about timing issues.

November 6, 2012: v0.3, r2717
------------------------------

Changes from r2713 include the following:

1. A bug in the decoder that led to erratic behavior (failed decodes)
under certain conditions has been corrected.  Decoding is now much
more reliable.

2. A valid algorithm is now used to calculate S/N values for received
JT9 signals.

3. The header format of recorded *.wav files has been corrected.
These files will now play correctly in Windows programs that expect
the standard header.

November 6, 2012: v0.2, r2713
------------------------------

Changes from r2711 include the following:

1. Updates to the Quick-Start User's Guide,
http://www.physics.princeton.edu/pulsar/K1JT/WSJT-X_Users_Guide.pdf

2. Double-click on waterfall now sets Tol to a reduced
(mode-dependent) value.

3. Tol is saved and restored on program restart.

4. A "digital gain" slider was added next to the green-bar audio level
indicator.  With the slider at mid-range, the scale reads correctly in
dB above the least significant bit of 16-bit audio data.

5. There is now a test that rejects at least one type of data that is
sufficiently corrupt to cause Eddie's best friend, the message
"15P6715P67WCV".

6. Several minor tweaks to improve decoder performance.

7. The program now starts with Monitor OFF.  You must click Monitor to
start accepting audio.  For some types of testing, this may be an
advantage.  This startup condition may be changed again, in the
future.

October 31, 2012: v0.2, r2711
-----------------------------

Three significant changes since r2706:

1. Three options are now provided on the "Decode" menu, controlling
the "depth" of the decoding process.  For most purposes I suggest you
should use "Normal", but feel free to experiment with the others.

2. Decoding of multiple signals in one Rx interval has been improved.

3. Handling of strong signals has been improved.

October 309, 2012: v0.2, r2706
------------------------------

Changes since r2702 include the following:

1. The problem with "ghost" signals is fixed.

2. A problem causing very long decode times under certain
circumstances has been fixed.  Please note: decode times on any recent
PC should no more than a few seconds!

3. I have re-directed the program's fatal error messages so they will
be sent to the command-prompt window from which you started the
program. Please send me full reports on any such messages you observe,
preferably with details on how to reproduce the problem.

#########################################################################

Some additional information ...

1. Yes, the JT9 modes require good stability in all system
oscillators.  The present JT9 bdecoder does not attempt to track
frequency drifts. Such capability will be added, however.  We have
been using digital modes for EME for nearly ten years now, at 144 MHz
and higher.  There are more than 1000 WSJT users on EME, using all
kinds of rige.  We have learned how to deal with reasonable rates of
drift.  Surely if we can do these things at VHF, we can do them much
more easily at MF and LF.

2. If you're sure that you have seen degraded JT9 performance because
of frequency stability issues, don't just complain on the LF
reflector. Document your case and send me an example file with a
drifting JT9 signal.  Making WSJT-X and JT9 better is partly YOUR
responsibility!

3. In other ways as well, test files are needed.  I can make many
tests myself, but I can't foresee all the problems others will have.
That's what the "Save All" function is for!  In these early tests,
always run with "Save All" checked, just in case you will want to
refer back to something that happened.  You may want to send me the
file in question.  You can always clean out your "Save" directory by
using "File | Delete all *.wav files in SaveDir".  I need good
examples of signals that fail to decode for any unknown reason.  Also
some good examples of atmospheric or other impulsive noise, for
testing the noise blanker.

4. I have added a page of "Hints for New Users" to the online WSJT-X
User's Guide,
http://www.physics.princeton.edu/pulsar/K1JT/WSJT-X_Users_Guide.pdf .
Please read it! ... and let me know if you find other operational
details of WSJT-X that need explanation.  This will likely be
especially true for those not already familiar with older versions of
WSJT.

5. An operational suggestion: In many ways the different JT9 submodes
are treated as distinct modes.  If you receive a JT9-x signal in a
different submode than the one you have selected, you won't decode
it. For this reason, if JT9 is to become popular we'll probably need
to choose one or two of the submodes for general use, and perhaps
assign a narrow slice of the band to each one.  Note that "message
averaging" in the Rx software can make two or three JT9-2
transmissions as good as one JT9-5 transmission, with the advantage
that you will copy sooner if signals are better than required for
JT9-5.  Message averaging is not yet present in the JT9 decoder... but
in future it can be.  Again, we have dealt with such issues very
effectively on EME -- and can do so at MF/LF, for sure.

6. On the topic of CW, Beacons, WSPR, JT9, etc.  I really don't
understand what all the fuss is about.  Surely there is room for
everybody?  Maybe I'm just too new here to understand?  (Mal, is this
mostly just a matter of "Mal being Mal"???)

On the HF bands, the WSPR sub-band is just 200 Hz wide.  If we did the
same on 630 m, the WSPR sub-band would take up less than 3% of the 7
kHz band.  If that's too much, we could cut it in half, or even less,
and still have enough WSPR space.  Moreover, a "slow WSPR", if
warranted, would require even less bandwidth.  Similar comments apply
to JT9.  The bandwidth of JT9 signals is significantly less than that
of CW, for comparable information rates.  There should be enough
spectrum for both, even in our narrow MF and LF bands.

7. As for performance comparisons between JT9 and WSPR: WSPR is a
mature program, and its decoder has been optimized and tweaked over a
period approaching five years.  You are playing with JT9 in infancy.
With help (as opposed to simple complaints) from users, it will
improve rapidly.

October 29, 2012: v0.2, r2702
-----------------------------
Changes since version 0.1, r2696 include the following:

1. Sample rate for audio output has been changed from 12000 to 48000
Hz.  Tx audio may now be generated at any frequency from 500 to 20000
Hz.

2. The Decoder now tries to decode all synchronizable signals in the
"green zone", that is, within "Tol" Hz of the selected QSO
frequency. (Before, by default it decoded only the signal producing
the highest "sync" value.  Other signals could be decoded by manually
setting the QSO frequency and reducing Tol as needed.)

3. The user's selected QSO Frequency is now saved and restored on
program restart.

4. The problem with re-initialization after changing sub-modes has
been fixed.

5. The problem (for some users) of not releasing PTT after end of a
transmission has been fixed.

6. The program now writes a log of all decodes to a file wsjtx_rx.log
in the wsjtx directory.

October 25, 2012: v0.1, r2695
-----------------------------
Initial version of WSJT-X (experimental WSJT) released for testing.


code:
// 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_ANGULAR_VELOCITY_DERIVED_DIMENSION_HPP
#define BOOST_UNITS_ANGULAR_VELOCITY_DERIVED_DIMENSION_HPP

#include <boost/units/derived_dimension.hpp>
#include <boost/units/physical_dimensions/plane_angle.hpp>
#include <boost/units/physical_dimensions/time.hpp>

namespace boost {

namespace units {

/// derived dimension for angular velocity : T^-1 QP
typedef derived_dimension<time_base_dimension,-1,
                          plane_angle_base_dimension,1>::type angular_velocity_dimension;

} // namespace units

} // namespace boost

#endif // BOOST_UNITS_ANGULAR_VELOCITY_DERIVED_DIMENSION_HPP


code:
/*
 * Copyright (c) 2012-2014 Glen Joseph Fernandes
 * glenfe at live dot com
 *
 * Distributed under the Boost Software License,
 * Version 1.0. (See accompanying file LICENSE_1_0.txt
 * or copy at http://boost.org/LICENSE_1_0.txt)
 */
#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
#define BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP

#include <boost/align/align.hpp>
#include <boost/smart_ptr/detail/array_traits.hpp>
#include <boost/smart_ptr/detail/array_utility.hpp>
#include <boost/type_traits/alignment_of.hpp>

namespace boost {
    namespace detail {
        struct ms_init_tag   { };
        struct ms_noinit_tag { };

        template<class T>
        struct ms_allocator_state;

        template<class T>
        struct ms_allocator_state<T[]> {
            typedef typename array_base<T>::type type;

            ms_allocator_state(std::size_t size_,
                type** result_)
                : size(size_ * array_total<T>::size),
                  result(result_) {
            }

            std::size_t size;

            union {
                type** result;
                type* object;
            };
        };

        template<class T, std::size_t N>
        struct ms_allocator_state<T[N]> {
            typedef typename array_base<T>::type type;

            ms_allocator_state(type** result_)
                : result(result_) {
            }

            enum {
                size = array_total<T[N]>::size
            };

            union {
                type** result;
                type* object;
            };
        };

        template<class A, class T, class R>
        class as_allocator
            : public A {
            template<class A_, class T_, class R_>
            friend class as_allocator;

#if !defined(BOOST_NO_CXX11_ALLOCATOR)
            typedef std::allocator_traits<A> AT;
            typedef typename AT::template rebind_alloc<char> CA;
            typedef typename AT::template rebind_traits<char> CT;
#else
            typedef typename A::template rebind<char>::other CA;
#endif

        public:
            typedef A allocator_type;

#if !defined(BOOST_NO_CXX11_ALLOCATOR)
            typedef typename AT::value_type value_type;
            typedef typename AT::pointer pointer;
            typedef typename AT::const_pointer const_pointer;
            typedef typename AT::void_pointer void_pointer;
            typedef typename AT::const_void_pointer const_void_pointer;
            typedef typename AT::size_type size_type;
            typedef typename AT::difference_type difference_type;
#else
            typedef typename A::value_type value_type;
            typedef typename A::pointer pointer;
            typedef typename A::const_pointer const_pointer;
            typedef typename A::size_type size_type;
            typedef typename A::difference_type difference_type;
            typedef typename A::reference reference;
            typedef typename A::const_reference const_reference;
            typedef void* void_pointer;
            typedef const void* const_void_pointer;
#endif

            template<class U>
            struct rebind {
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
                typedef as_allocator<typename AT::
                    template rebind_alloc<U>, T, R> other;
#else
                typedef as_allocator<typename A::
                    template rebind<U>::other, T, R> other;
#endif
            };

            typedef typename array_base<T>::type type;

            as_allocator(const A& allocator_, type** result)
                : A(allocator_),
                  data(result) {
            }

            as_allocator(const A& allocator_, std::size_t size,
                type** result)
                : A(allocator_),
                  data(size, result) {
            }

            template<class U>
            as_allocator(const as_allocator<U, T, R>& other)
                : A(other.allocator()),
                  data(other.data) {
            }

            pointer allocate(size_type count, const_void_pointer = 0) {
                enum {
                    M = boost::alignment_of<type>::value
                };
                std::size_t n1 = count * sizeof(value_type);
                std::size_t n2 = data.size * sizeof(type);
                std::size_t n3 = n2 + M;
                CA ca(allocator());
                void* p1 = ca.allocate(n1 + n3);
                void* p2 = static_cast<char*>(p1) + n1;
                (void)boost::alignment::align(M, n2, p2, n3);
                *data.result = static_cast<type*>(p2);
                return static_cast<value_type*>(p1);
            }

            void deallocate(pointer memory, size_type count) {
                enum {
                    M = boost::alignment_of<type>::value
                };
                std::size_t n1 = count * sizeof(value_type);
                std::size_t n2 = data.size * sizeof(type) + M;
                char* p1 = reinterpret_cast<char*>(memory);
                CA ca(allocator());
                ca.deallocate(p1, n1 + n2);
            }

            const A& allocator() const {
                return static_cast<const A&>(*this);
            }

            A& allocator() {
                return static_cast<A&>(*this);
            }

            void set(type* memory) {
                data.object = memory;
            }

            void operator()() {
                if (data.object) {
                    R tag;
                    release(tag);
                }
            }

        private:
            void release(ms_init_tag) {
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
                as_destroy(allocator(), data.object, data.size);
#else
                ms_destroy(data.object, data.size);
#endif
            }

            void release(ms_noinit_tag) {
                ms_destroy(data.object, data.size);
            }

            ms_allocator_state<T> data;
        };

        template<class A1, class A2, class T, class R>
        bool operator==(const as_allocator<A1, T, R>& a1,
            const as_allocator<A2, T, R>& a2) {
            return a1.allocator() == a2.allocator();
        }

        template<class A1, class A2, class T, class R>
        bool operator!=(const as_allocator<A1, T, R>& a1,
            const as_allocator<A2, T, R>& a2) {
            return a1.allocator() != a2.allocator();
        }

        template<class T, class Y = char>
        class ms_allocator;

        template<class T, class Y>
        class ms_allocator {
            template<class T_, class Y_>
            friend class ms_allocator;

        public:
            typedef typename array_base<T>::type type;

            typedef Y value_type;
            typedef Y* pointer;
            typedef const Y* const_pointer;
            typedef std::size_t size_type;
            typedef std::ptrdiff_t difference_type;
            typedef Y& reference;
            typedef const Y& const_reference;

            template<class U>
            struct rebind {
                typedef ms_allocator<T, U> other;
            };

            ms_allocator(type** result)
                : data(result) {
            }

            ms_allocator(std::size_t size, type** result)
                : data(size, result) {
            }

            template<class U>
            ms_allocator(const ms_allocator<T, U>& other)
                : data(other.data) {
            }

            pointer allocate(size_type count, const void* = 0) {
                enum {
                    M = boost::alignment_of<type>::value
                };
                std::size_t n1 = count * sizeof(Y);
                std::size_t n2 = data.size * sizeof(type);
                std::size_t n3 = n2 + M;
                void* p1 = ::operator new(n1 + n3);
                void* p2 = static_cast<char*>(p1) + n1;
                (void)boost::alignment::align(M, n2, p2, n3);
                *data.result = static_cast<type*>(p2);
                return static_cast<Y*>(p1);
            }

            void deallocate(pointer memory, size_type) {
                void* p1 = memory;
                ::operator delete(p1);
            }

#if defined(BOOST_NO_CXX11_ALLOCATOR)
            pointer address(reference value) const {
                return &value;
            }

            const_pointer address(const_reference value) const {
                return &value;
            }

            size_type max_size() const {
                enum {
                    N = static_cast<std::size_t>(-1) / sizeof(Y)
                };
                return N;
            }

            void construct(pointer memory, const_reference value) {
                void* p1 = memory;
                ::new(p1) Y(value);
            }

            void destroy(pointer memory) {
                (void)memory;
                memory->~Y();
            }
#endif

            void set(type* memory) {
                data.object = memory;
            }

            void operator()() {
                if (data.object) {
                    ms_destroy(data.object, data.size);
                }
            }

        private:
            ms_allocator_state<T> data;
        };

        template<class T, class Y1, class Y2>
        bool operator==(const ms_allocator<T, Y1>&,
            const ms_allocator<T, Y2>&) {
            return true;
        }

        template<class T, class Y1, class Y2>
        bool operator!=(const ms_allocator<T, Y1>&,
            const ms_allocator<T, Y2>&) {
            return false;
        }

        class ms_in_allocator_tag {
        public:
            void operator()(const void*) {
            }
        };
    }
}

#endif


code:
/* Reed-Solomon decoder
 * Copyright 2002 Phil Karn, KA9Q
 * May be used under the terms of the GNU General Public License (GPL)
 * Modified by Steve Franke, K9AN, for use in a soft-symbol RS decoder
 */

#ifdef DEBUG
#include <stdio.h>
#endif

#include <stdlib.h>
#include <string.h>

#define	min(a,b)	((a) < (b) ? (a) : (b))

#ifdef FIXED
#include "fixed.h"
#elif defined(BIGSYM)
#include "int.h"
#else
#include "char.h"
#endif

int DECODE_RS(
#ifndef FIXED
              void *p,
#endif
              DTYPE *data, int *eras_pos, int no_eras, int calc_syn){

#ifndef FIXED
    struct rs *rs = (struct rs *)p;
#endif
    int deg_lambda, el, deg_omega;
    int i, j, r,k;
    DTYPE u,q,tmp,num1,num2,den,discr_r;
    DTYPE lambda[NROOTS+1];	// Err+Eras Locator poly
    static DTYPE s[51];					 // and syndrome poly
    DTYPE b[NROOTS+1], t[NROOTS+1], omega[NROOTS+1];
    DTYPE root[NROOTS], reg[NROOTS+1], loc[NROOTS];
    int syn_error, count;

    if( calc_syn ) {
        /* form the syndromes; i.e., evaluate data(x) at roots of g(x) */
        for(i=0;i<NROOTS;i++)
            s[i] = data[0];

        for(j=1;j<NN;j++){
            for(i=0;i<NROOTS;i++){
                if(s[i] == 0){
                    s[i] = data[j];
                } else {
                    s[i] = data[j] ^ ALPHA_TO[MODNN(INDEX_OF[s[i]] + (FCR+i)*PRIM)];
                }
            }
        }

        /* Convert syndromes to index form, checking for nonzero condition */
        syn_error = 0;
        for(i=0;i<NROOTS;i++){
            syn_error |= s[i];
            s[i] = INDEX_OF[s[i]];
        }

        if (!syn_error) {
            /* if syndrome is zero, data[] is a codeword and there are no
             * errors to correct. So return data[] unmodified
             */
            count = 0;
            goto finish;
        }

    }

    memset(&lambda[1],0,NROOTS*sizeof(lambda[0]));
    lambda[0] = 1;

    if (no_eras > 0) {
        /* Init lambda to be the erasure locator polynomial */
        lambda[1] = ALPHA_TO[MODNN(PRIM*(NN-1-eras_pos[0]))];
        for (i = 1; i < no_eras; i++) {
            u = MODNN(PRIM*(NN-1-eras_pos[i]));
            for (j = i+1; j > 0; j--) {
                tmp = INDEX_OF[lambda[j - 1]];
                if(tmp != A0)
                    lambda[j] ^= ALPHA_TO[MODNN(u + tmp)];
            }
        }

#if DEBUG >= 1
        /* Test code that verifies the erasure locator polynomial just constructed
         Needed only for decoder debugging. */

        /* find roots of the erasure location polynomial */
        for(i=1;i<=no_eras;i++)
            reg[i] = INDEX_OF[lambda[i]];

        count = 0;
        for (i = 1,k=IPRIM-1; i <= NN; i++,k = MODNN(k+IPRIM)) {
            q = 1;
            for (j = 1; j <= no_eras; j++)
                if (reg[j] != A0) {
                    reg[j] = MODNN(reg[j] + j);
                    q ^= ALPHA_TO[reg[j]];
                }
            if (q != 0)
                continue;
            /* store root and error location number indices */
            root[count] = i;
            loc[count] = k;
            count++;
        }
        if (count != no_eras) {
            printf("count = %d no_eras = %d\n lambda(x) is WRONG\n",count,no_eras);
            count = -1;
            goto finish;
        }
#if DEBUG >= 2
        printf("\n Erasure positions as determined by roots of Eras Loc Poly:\n");
        for (i = 0; i < count; i++)
            printf("%d ", loc[i]);
        printf("\n");
#endif
#endif
    }
    for(i=0;i<NROOTS+1;i++)
        b[i] = INDEX_OF[lambda[i]];

    /*
     * Begin Berlekamp-Massey algorithm to determine error+erasure
     * locator polynomial
     */
    r = no_eras;
    el = no_eras;
    while (++r <= NROOTS) {	/* r is the step number */
        /* Compute discrepancy at the r-th step in poly-form */
        discr_r = 0;
        for (i = 0; i < r; i++){
            if ((lambda[i] != 0) && (s[r-i-1] != A0)) {
                discr_r ^= ALPHA_TO[MODNN(INDEX_OF[lambda[i]] + s[r-i-1])];
            }
        }
        discr_r = INDEX_OF[discr_r];	/* Index form */
        if (discr_r == A0) {
            /* 2 lines below: B(x) <-- x*B(x) */
            memmove(&b[1],b,NROOTS*sizeof(b[0]));
            b[0] = A0;
        } else {
            /* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
            t[0] = lambda[0];
            for (i = 0 ; i < NROOTS; i++) {
                if(b[i] != A0)
                    t[i+1] = lambda[i+1] ^ ALPHA_TO[MODNN(discr_r + b[i])];
                else
                    t[i+1] = lambda[i+1];
            }
            if (2 * el <= r + no_eras - 1) {
                el = r + no_eras - el;
                /*
                 * 2 lines below: B(x) <-- inv(discr_r) *
                 * lambda(x)
                 */
                for (i = 0; i <= NROOTS; i++)
                    b[i] = (lambda[i] == 0) ? A0 : MODNN(INDEX_OF[lambda[i]] - discr_r + NN);
            } else {
                /* 2 lines below: B(x) <-- x*B(x) */
                memmove(&b[1],b,NROOTS*sizeof(b[0]));
                b[0] = A0;
            }
            memcpy(lambda,t,(NROOTS+1)*sizeof(t[0]));
        }
    }

    /* Convert lambda to index form and compute deg(lambda(x)) */
    deg_lambda = 0;
    for(i=0;i<NROOTS+1;i++){
        lambda[i] = INDEX_OF[lambda[i]];
        if(lambda[i] != A0)
            deg_lambda = i;
    }
    /* Find roots of the error+erasure locator polynomial by Chien search */
    memcpy(&reg[1],&lambda[1],NROOTS*sizeof(reg[0]));
    count = 0;		/* Number of roots of lambda(x) */
    for (i = 1,k=IPRIM-1; i <= NN; i++,k = MODNN(k+IPRIM)) {
        q = 1; /* lambda[0] is always 0 */
        for (j = deg_lambda; j > 0; j--){
            if (reg[j] != A0) {
                reg[j] = MODNN(reg[j] + j);
                q ^= ALPHA_TO[reg[j]];
            }
        }
        if (q != 0)
            continue; /* Not a root */
        /* store root (index-form) and error location number */
#if DEBUG>=2
        printf("count %d root %d loc %d\n",count,i,k);
#endif
        root[count] = i;
        loc[count] = k;
        /* If we've already found max possible roots,
         * abort the search to save time
         */
        if(++count == deg_lambda)
            break;
    }
    if (deg_lambda != count) {
        /*
         * deg(lambda) unequal to number of roots => uncorrectable
         * error detected
         */
        count = -1;
        goto finish;
    }
    /*
     * Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
     * x**NROOTS). in index form. Also find deg(omega).
     */
    deg_omega = 0;
    for (i = 0; i < NROOTS;i++){
        tmp = 0;
        j = (deg_lambda < i) ? deg_lambda : i;
        for(;j >= 0; j--){
            if ((s[i - j] != A0) && (lambda[j] != A0))
                tmp ^= ALPHA_TO[MODNN(s[i - j] + lambda[j])];
        }
        if(tmp != 0)
            deg_omega = i;
        omega[i] = INDEX_OF[tmp];
    }
    omega[NROOTS] = A0;

    /*
     * Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
     * inv(X(l))**(FCR-1) and den = lambda_pr(inv(X(l))) all in poly-form
     */
    for (j = count-1; j >=0; j--) {
        num1 = 0;
        for (i = deg_omega; i >= 0; i--) {
            if (omega[i] != A0)
                num1  ^= ALPHA_TO[MODNN(omega[i] + i * root[j])];
        }
        num2 = ALPHA_TO[MODNN(root[j] * (FCR - 1) + NN)];
        den = 0;

        /* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
        for (i = min(deg_lambda,NROOTS-1) & ~1; i >= 0; i -=2) {
            if(lambda[i+1] != A0)
                den ^= ALPHA_TO[MODNN(lambda[i+1] + i * root[j])];
        }
        if (den == 0) {
#if DEBUG >= 1
            printf("\n ERROR: denominator = 0\n");
#endif
            count = -1;
            goto finish;
        }
        /* Apply error to data */
        if (num1 != 0) {
            data[loc[j]] ^= ALPHA_TO[MODNN(INDEX_OF[num1] + INDEX_OF[num2] + NN - INDEX_OF[den])];
        }
    }
finish:
    if(eras_pos != NULL){
        for(i=0;i<count;i++)
            eras_pos[i] = loc[i];
    }
    return count;
}


code:
// Boost.Range library
//
//  Copyright Neil Groves 2009. Use, modification and
//  distribution is subject to the Boost Software License, Version
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_ALGORITHM_EXT_IOTA_HPP_INCLUDED
#define BOOST_RANGE_ALGORITHM_EXT_IOTA_HPP_INCLUDED

#include <boost/range/config.hpp>
#include <boost/range/concepts.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>

namespace boost
{
    namespace range
    {

template< class ForwardRange, class Value >
inline ForwardRange& iota( ForwardRange& rng, Value x )
{
    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
    typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;

    iterator_t last_target = ::boost::end(rng);
    for (iterator_t target = ::boost::begin(rng); target != last_target; ++target, ++x)
        *target = x;

    return rng;
}

template< class ForwardRange, class Value >
inline const ForwardRange& iota( const ForwardRange& rng, Value x )
{
    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
    typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type iterator_t;

    iterator_t last_target = ::boost::end(rng);
    for (iterator_t target = ::boost::begin(rng); target != last_target; ++target, ++x)
        *target = x;

    return rng;
}

    } // namespace range
    using range::iota;
} // namespace boost

#endif // include guard


code:
/*=============================================================================
    Copyright (c) 2006-2007 Tobias Schwinger

    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).
==============================================================================*/

#if !defined(BOOST_FUSION_FUNCTIONAL_ADAPTER_DETAIL_ACCESS_HPP_INCLUDED)
#define BOOST_FUSION_FUNCTIONAL_ADAPTER_DETAIL_ACCESS_HPP_INCLUDED

namespace boost { namespace fusion { namespace detail
{
    // const reference deduction for function templates that accept T const &
    template <typename T> struct cref               { typedef T const& type; };
    template <typename T> struct cref<T&>           { typedef T const& type; };
    template <typename T> struct cref<T const>      { typedef T const& type; };

    // mutable reference deduction for function templates that accept T &
    template <typename T> struct mref               { typedef T      & type; };
    template <typename T> struct mref<T&>           { typedef T      & type; };

    // generic reference deduction for function templates that are overloaded
    // to accept both T const & and T &
    template <typename T> struct gref               { typedef T const& type; };
    template <typename T> struct gref<T&>           { typedef T      & type; };
    template <typename T> struct gref<T const>      { typedef T const& type; };

    // appropriately qualified target function in const context
    template <typename T> struct qf_c          { typedef T const  type; };
    template <typename T> struct qf_c<T const> { typedef T const  type; };
    template <typename T> struct qf_c<T &>     { typedef T        type; };

    // appropriately qualified target function in non-const context
    template <typename T> struct qf            { typedef T        type; };
    template <typename T> struct qf<T const>   { typedef T const  type; };
    template <typename T> struct qf<T &>       { typedef T        type; };
}}}

#endif