jade::basic_rema< TChar > Class Template Reference

A template for a class that reduces columns of matrices given to it. The columns to keep are chosen at random, but their relative order is not changed. More...

#include <jade.rema.hpp>

Collaboration diagram for jade::basic_rema< TChar >:

Public Types
typedef TChar	char_type
	A character. More...
typedef std::basic_istream< char_type >	istream
	An input stream. More...
typedef std::basic_ostream< char_type >	ostream
	An output stream. More...

Public Member Functions
	basic_rema (jade::args &a)
	Initializes a new instance of the class, reading the command-line arguments. More...
void	execute (istream &in, ostream &out)
	Executes the filter through the specified streams. More...

Detailed Description

template<typename TChar>
class jade::basic_rema< TChar >

A template for a class that reduces columns of matrices given to it. The columns to keep are chosen at random, but their relative order is not changed.

Definition at line 21 of file jade.rema.hpp.

Member Typedef Documentation

char_type

template<typename TChar >

typedef TChar jade::basic_rema< TChar >::char_type

A character.

Definition at line 24 of file jade.rema.hpp.

istream

template<typename TChar >

typedef std::basic_istream<char_type> jade::basic_rema< TChar >::istream

An input stream.

Definition at line 25 of file jade.rema.hpp.

ostream

template<typename TChar >

typedef std::basic_ostream<char_type> jade::basic_rema< TChar >::ostream

An output stream.

Definition at line 26 of file jade.rema.hpp.

Constructor & Destructor Documentation

basic_rema()

template<typename TChar >

jade::basic_rema< TChar >::basic_rema ( jade::args &  a )

inlineexplicit

Initializes a new instance of the class, reading the command-line arguments.

Parameters

a	The command-line arguments.

Definition at line 32 of file jade.rema.hpp.

            : _engine      ()
            , _seed        (_read_seed(a))
            , _num_markers (_read_num_markers(a))
        {
        }

Member Function Documentation

execute()

template<typename TChar >

void jade::basic_rema< TChar >::execute ( istream &  in, ostream &  out  )

inline

Executes the filter through the specified streams.

Parameters

in	The input stream.
out	The output stream.

Definition at line 43 of file jade.rema.hpp.

        {
            //
            // Read the dimensions of the matrix; this must be successful for
            // the first matrix.
            //
            size_t row_count, col_count;
            if (!(in >> row_count >> col_count))
                throw jade::error("error reading matrix dimensions");
 
            //
            // Do not try to keep more markers than the number of columns in
            // the input matrix.
            //
            const auto marker_count = std::min(col_count, _num_markers);
 
            //
            // Using the appropriate seed, randomly shuffle a vector that
            // contains all the possible indices of the matrix; then record a
            // set of bits to mark the columns to keep.
            //
            std::vector<bool> filter_flags;
            filter_flags.resize(col_count, true);
            {
                typedef std::vector<size_t> vector_type;
                vector_type indices (col_count);
                std::iota(indices.begin(), indices.end(), 0);
                _engine.seed(_seed);
                std::shuffle(indices.begin(), indices.end(), _engine);
                indices.resize(marker_count);
                for (const auto index : indices)
                    filter_flags[index] = false;
            }
 
            //
            // Filter the first matrix.
            //
            _filter(in, out, row_count, col_count, marker_count, filter_flags);
 
            //
            // Attempt to read a row; if this fails, assume this is the end of
            // the data (a discrete genotype matrix), but otherwise, require
            // the column, require consistent dimensions, and then read the
            // second matrix.
            //
            size_t r, c;
            if (!(in >> r) && in.eof())
                return;
            if (!(in >> c))
                throw jade::error("error reading second matrix dimensions");
            if (r != row_count || c != col_count)
                throw jade::error("inconsistent second matrix dimensions");
 
            out << char_type('\n');
            _filter(in, out, row_count, col_count, marker_count, filter_flags);
 
            //
            // Require the third matrix of a consistent size.
            //
            if (!(in >> r >> c))
                throw jade::error("error reading third matrix dimensions");
            if (r != row_count || c != col_count)
                throw jade::error("inconsistent third matrix dimensions");
 
            out << char_type('\n');
            _filter(in, out, row_count, col_count, marker_count, filter_flags);
 
            //
            // Require the end of the data.
            //
            for (;;)
            {
                const auto ch = in.get();
                if (ch < 0)
                    return;
                if (!std::isspace(ch))
                    throw jade::error("unexpected symbol after matrix data");
            }
        }

---

The documentation for this class was generated from the following file:

• jade.rema.hpp