This class can compute the most simple form of alignment. More...

#include <musaline.hpp>

Public Types
typedef CostCalc	CostCalculator

Public Member Functions
	LinearAligner (CostCalculator ccal=CostCalculator())
	Constructor. More...

void	set_cost_calculator (CostCalculator ccal)
	Set a different CostCalculator object.

CostCalculator const &	get_cost_calculator () const
	Get a const reference to the current CostCalculator object.

template<class Sequence0 , class Sequence1 >
Alignment	global_align (Sequence0 const &seq0, Sequence1 const &seq1) const

template<class Sequence0 , class Sequence1 >
Alignment	cut_one_end_off_align (Sequence0 const &seq0, Sequence1 const &seq1) const

template<class Sequence0 , class Sequence1 >
Alignment	cut_one_begin_off_align (Sequence0 const &seq0, Sequence1 const &seq1) const

template<class Sequence0 , class Sequence1 >
Alignment	initial_align (Sequence0 const &seq0, Sequence1 const &seq1) const

template<class Sequence0 , class Sequence1 >
Alignment	end_align (Sequence0 const &seq0, Sequence1 const &seq1) const

template<class Sequence0 , class Sequence1 >
Alignment	inside_align (Sequence0 const &seq0, Sequence1 const &seq1) const

template<class Sequence0 , class Sequence1 >
Alignment	semi_align (Sequence0 const &seq0, Sequence1 const &seq1) const

template<class Sequence0 , class Sequence1 >
Alignment	partial_align (Sequence0 const &seq0, Sequence1 const &seq1) const
	No requirement for start and end.

Detailed Description

template<class CostCalc>
class musaline::LinearAligner< CostCalc >

This class can compute the most simple form of alignment.

An element of a sequence can be aligned with an element of the other sequence or with a gap. The cost of aligning two elements or an element with a gap, does not depend on the context.

The class has several align functions which differ in what part of the sequences should be aligned. Details are provided with the individual align functions.

This class takes a CostCalculator class as a template parameter. This class shall be provided by the user and gives the benefit of matching one element with another one. If you can call the following function template with your cost calculator and sequences, you should be OK. More detailed requirements are listed after the function.

#include "boost/range.hpp"
    template <class CostCalculator, class Sequence0, class Sequence1>
    void linear_usage(CostCalculator const &ccal,
            Sequence0 const &seq0, Sequence1 const &seq1)
    {
        // Copy constructor
        CostCalculator ccal_copy(ccal);
        // assignment operator
        ccal_copy = ccal;
        ccal.preprocess(seq0, seq1);
        double d = ccal.gap_bft();
        size_t sz0 = boost::distance(seq0);
        size_t sz1 = boost::distance(seq1);
        auto s0cur = boost::const_begin(seq0);
        for (size_t i=0; i!=sz0; ++i) {
            auto s1cur = boost::const_begin(seq1));
            for (size_t j=0; j!=sz1; ++j) {
                double benefit = ccal.match(*s0cur, *s1cur);
                ++s1cur;
            }
            ++s0cur;
        }
    }

The classes Sequence0 and Sequence1 should fulfill the requirements for a boost Forward Range. See the documentation of the range library on http://www.boost.org for full details. A range can be thought of as a 'container light'. It should give access to a begin and end iterator, which should be forward iterators.

The CostCalculator class should have the following member functions:

a copy constructor and an assignment operator.
match which takes an element of seq0 and an element of seq1 and returns a double. This value is a measure for how well the two elements match. A good match should yield a (big) positive value. A bad match should yield a negative value.
gap_bft. Returns the benefit for matching an element with a gap (nothing). The returned value should be negative, otherwise, the results are not guaranteed to be the optimal solution.
preprocess which takes two sequences as argument. This member function is guaranteed to be called before any call to match for those sequences. This may be used to do some preprocessing of the sequences. For instance, say we want to compare two melodies, where a melody is a sequences of notes and a key. If one of the melodies is in C and the other one is in G, we might want to transpose the latter melody. This can be done in the preprocess step.

In introductory page you can find a more gentle (and less precise) description of the requirements.

Constructor & Destructor Documentation

template<class CostCalc >

musaline::LinearAligner< CostCalc >::LinearAligner ( CostCalculator ccal = CostCalculator() )

inline

Constructor.