Miscellaneous functionality. More...

Classes
class	Aligner
	Aligning two sequences. More...

class	CigarIterator
	Iterator over a CIGAR. More...

class	ColumnStream

class	CommandLine
	Class for parsing the command line. More...

class	Container2D
	Concept check for Container2D. More...

class	Mutable_Container2D
	Concept check for Mutable Container2D. More...

class	TrivialIterator
	Concept check for Trivial Iterator More...

class	DataIteratorConcept
	Concept check for Data Iterator. More...

class	DistanceConcept
	Concept check for a Distance. More...

class	Container2DIterator
	Iterator for a Container2D. More...

class	DataIterator
	DataIterator. More...

class	DataWeight
	Holds a pair of data and associated weight. More...

class	DataWeightProxy
	Proxy class for DataWeight. More...

class	Deleter
	Functor that deletes an object. More...

class	runtime_error
	Class used for all runtime error detected within yat library. More...

class	cmd_error
	Class used for error reported from Commandline or Option. More...

class	errno_error
	Class that contains information reported via global variable errno. More...

class	GSL_error
	Class for errors reported from underlying GSL calls. More...

class	IO_error
	Class to report errors associated with IO operations. More...

class	FileUtil
	Checking file/directory existence and access permissions. More...

class	GetlineIterator
	Read from std::istream with std::getline. More...

class	Index
	Class for storing indices of, e.g., a MatrixLookup. More...

struct	unweighted_iterator_tag

struct	weighted_iterator_tag

struct	weighted_iterator_traits

struct	weighted_if_any2

struct	weighted_if_any3

struct	iterator_traits

class	KernelMatrix
	A KernelMatrix is a Container2D. More...

class	KernelPCA
	Principal Component Analysis on a Kernel Matrix. More...

class	kNNI
	kNNimpute More...

class	Matrix
	Interface to GSL matrix. More...

class	MatrixWeighted
	Weighted Matrix. More...

class	MergeIterator
	Iterate over several ranges as if ranges have been merged. More...

class	NNI
	Interface class for nearest neighbour imputation (NNI) algorithms. More...

class	Option
	Container of variables for an option. More...

class	OptionArg
	Option with argument. More...

class	OptionFile
	Class for file related options. More...

class	OptionInFile
	Class for file related options. More...

class	OptionOutFile
	Class for file related options. More...

class	OptionHelp
	Class for help option. More...

class	OptionSwitch
	Class for switch option. More...

class	OstreamIterator

class	PCA
	Principal Component Analysis. More...

class	PriorityQueue
	Multi-thread safe priority queue. More...

class	Queue
	Multi-thread safe queue. More...

class	Scheduler
	Handle a number of jobs and send them to threads. More...

class	Segment
	a class for a Segment or Interval More...

struct	SegmentCompare
	functor using compare More...

class	SegmentMap
	a map of Segments More...

class	SegmentSet
	a set of Segments More...

class	SegmentTree
	Base Class for SegmentSet and SegmentMap. More...

class	SmartPtr

class	SmithWaterman

class	BasicStreamRedirect
	Redirect a stream to another stream. More...

class	Range
	A class for storing a shallow copy of a Range. More...

struct	abs

struct	Dereferencer
	Adaptor between pointer and pointee interface. More...

class	compose_f_gx_hy

class	compose_f_gxy

class	compose_f_gx

class	compose_f_gx_hx

struct	Exp

struct	Identity
	Identity functor that returns its argument. More...

class	get_error
	error class used in get(const std::map<Key, Tp, Compare, Alloc>& m, const Key& k) More...

struct	less_nan
	Functor that behaves like std::less with the exception that it treats NaN as a number larger than infinity. More...

struct	less_nan< DataWeight >
	Specialization for DataWeight. More...

class	Log

struct	pair_value_compare
	Functor comparing pairs using second. More...

struct	PairFirst
	Functor that return std::pair.first. More...

struct	PairSecond
	Functor that return std::pair.second. More...

class	StrideIterator
	Adaptor using a stride on underlying iterator. More...

class	SVD
	Singular Value Decomposition. More...

class	TypeInfo
	Wrapper class for storing std::type_info. More...

class	Vector
	This is the yat interface to GSL vector. More...

class	VectorBase
	This is the yat interface to GSL vector. More...

class	VectorConstView
	Read-only view. More...

class	VectorMutable
	This is the mutable interface to GSL vector. More...

class	VectorView
	This is the yat interface to gsl_vector_view. More...

struct	WeightedIteratorArchetype_ctor_arg

class	WeightedIteratorArchetype

class	WeightedIterator
	WeightedIterator. More...

class	WeightIterator
	WeightIterator. More...

class	WeNNI
	Weighted Nearest Neighbour Imputation. More...

Typedefs
typedef BasicStreamRedirect< char >	StreamRedirect

typedef BasicStreamRedirect < wchar_t >	wStreamRedirect

Functions
double	NeedlemanWunsch (const utility::Matrix &s, std::vector< std::pair< size_t, size_t > > &path, const double gap)

double	SmithWaterman (const utility::Matrix &s, double gap, double open_gap)
	Local alignment following the Smith-Waterman algorithm. More...

double	ssearch (std::string first, std::string second, double gap, double open_gap, double mismatch=0.0)

template<class Iter >
void	check_iterator_is_unweighted (Iter iter)
	check (at compile time) that iterator is unweighted. More...

Vector	operator* (const VectorBase &, const Matrix &)
	Matrix Vector multiplication.

template<class Container2D >
void	merge (const Container2D &x, std::vector< std::string > &labels, Matrix &y)
	merge rows in a Container2D More...

template<class Container2D , class Functor >
void	merge (const Container2D &x, std::vector< std::string > &labels, Matrix &y, Functor func)
	merge rows in a Container2D using a Functor More...

template<class Container2D , class Functor1 , class Functor2 >
void	merge (const Container2D &x, std::vector< std::string > &labels, MatrixWeighted &y, Functor1 data_func, Functor2 weight_func)
	merge rows in a Container2D to a MatrixWeighted More...

template<typename InputIterator >
void	sort_index (InputIterator first, InputIterator last, std::vector< size_t > &sort_index)

template<typename InputIterator , class Compare >
void	sort_index (InputIterator first, InputIterator last, std::vector< size_t > &sort_index, Compare comp)

void	split (std::vector< std::string > &result, const std::string &str, char delim)
	split a string into several substrings More...

void	split (std::vector< std::string > &result, const std::string &str, const std::string &delim)
	split a string into substrings More...

template<typename T1 , typename T2 >
bool	operator== (const Range< T1 > &, const Range< T2 > &)
	Equality comparison. More...

template<typename T1 , typename T2 >
bool	operator!= (const Range< T1 > &, const Range< T2 > &)
	Based on operator==. More...

template<typename T1 , typename T2 >
bool	operator< (const Range< T1 > &lhs, const Range< T2 > &rhs)
	Ordering relation. More...

template<typename T1 , typename T2 >
bool	operator<= (const Range< T1 > &lhs, const Range< T2 > &rhs)

template<typename T1 , typename T2 >
bool	operator> (const Range< T1 > &, const Range< T2 > &)

template<typename T1 , typename T2 >
bool	operator>= (const Range< T1 > &, const Range< T2 > &)

template<typename T >
void	clear (std::vector< T > &vec)
	reduce size and capacity to zero More...

template<typename Key , typename Tp , typename Compare , typename Alloc , typename Key2 >
const Tp &	get (const std::map< Key, Tp, Compare, Alloc > &m, const Key2 &k)

template<typename InputIterator , typename Key , typename Comp >
void	inverse (InputIterator first, InputIterator last, std::map< Key, std::vector< size_t >, Comp > &m)

template<typename Key , typename InputIterator , typename Comp >
void	inverse (InputIterator first, InputIterator last, std::multimap< Key, size_t, Comp > &m)

template<typename InputIterator , typename Key , typename Comp >
void	inverse (InputIterator first, InputIterator last, std::map< Key, size_t, Comp > &m)

template<typename T >
T	max (const T &a, const T &b, const T &c)

template<typename T >
T	max (const T &a, const T &b, const T &c, const T &d)

template<typename T >
T	max (const T &a, const T &b, const T &c, const T &d, const T &e)

template<typename T >
T	max (const T &a, const T &b, const T &c, const T &d, const T &e, const T &f)

template<class Iter >
boost::transform_iterator < PairFirst< typename boost::remove_reference < typename std::iterator_traits< Iter > ::reference >::type >, Iter >	pair_first_iterator (Iter i)

template<class Iter >
boost::transform_iterator < PairSecond< typename boost::remove_reference < typename std::iterator_traits< Iter > ::reference >::type >, Iter >	pair_second_iterator (Iter i)

template<typename Pointer , class Compare >
compose_f_gx_hy< Compare, Dereferencer< Pointer > , Dereferencer< Pointer > >	make_ptr_compare (Pointer p, Compare compare)

template<typename Pointer >
compose_f_gx_hy< std::less < typename std::iterator_traits< Pointer > ::value_type >, Dereferencer < Pointer >, Dereferencer < Pointer > >	make_ptr_compare (Pointer p)

std::string &	to_lower (std::string &s)
	Function converting a string to lower case.

std::string &	to_upper (std::string &s)
	Function converting a string to upper case.

std::string	basename (const std::string &fn)

template<typename InputIterator , typename OutputIterator >
bool	binary_weight (InputIterator first, InputIterator last, OutputIterator result)

void	chdir (const std::string &dir)

void	chmod (const std::string &filename, mode_t mode)

template<typename T >
std::string	convert (T input)
	convert T to a string More...

template<typename T >
T	convert (const std::string &s)
	convert string to (numerical) type More...

void	copy_file (const std::string &source, const std::string &target)
	Copy file source to target. More...

std::string	dirname (const std::string &fn)

bool	fnmatch (const std::string &pattern, const std::string &str, int flags=0)

template<typename T >
bool	is (const std::string &s)
	check if string is convertible to (numerical) type `T` More...

bool	is_double (const std::string &)

bool	is_equal (std::string s, std::string other)

bool	is_float (const std::string &)

bool	is_int (const std::string &)

bool	is_nan (const std::string &s)

template<typename T >
void	load (std::istream &is, std::vector< std::vector< T > > &vec, char sep='\0', char line_sep='\n', bool ignore_empty=false, bool rectangle=true)

template<typename T >
void	load (std::istream &is, std::vector< T > &vec, char sep='\0')
	Fill a vector<T> with elements from istream. More...

template<typename T >
T	log2 (T x)

void	mkdir (const std::string &dir, mode_t mode=0777)
	create a directory dir More...

void	mkdir_p (const std::string &dir, mode_t mode=0777)

void	remove (const std::string &fn)

void	rename (const std::string &from, const std::string &to)

void	replace (std::string &full_str, std::string old_str, std::string new_str)

template<typename Iterator >
double	sum_weight (Iterator first, Iterator last)

void	sort_index (std::vector< size_t > &sort_index, const VectorBase &invec)

void	sort_smallest_index (std::vector< size_t > &sort_index, size_t k, const VectorBase &invec)

void	sort_largest_index (std::vector< size_t > &sort_index, size_t k, const VectorBase &invec)

void	shuffle (VectorMutable &invec)

void	sort (VectorMutable &vec)

unsigned int	major_version (void)

unsigned int	minor_version (void)

unsigned int	patch_version (void)

std::string	version (void)

Detailed Description

Miscellaneous functionality.

Needed yat functionality that we don't know where to put usually ends up in the utility namespace until we figure out their proper namespace location.

Typedef Documentation

typedef BasicStreamRedirect<char> theplu::yat::utility::StreamRedirect

Since: New in yat 0.6

typedef BasicStreamRedirect<wchar_t> theplu::yat::utility::wStreamRedirect

Since: New in yat 0.6

Function Documentation

std::string theplu::yat::utility::basename ( const std::string & fn )

Same as posix C function with same name but works on std::string rather than char*.

See Also: http://linux.die.net/man/3/basename

Returns: everything after last '/'

Since: New in yat 0.10

template<typename InputIterator , typename OutputIterator >

bool theplu::yat::utility::binary_weight	(	InputIterator	first,
		InputIterator	last,
		OutputIterator	result
	)

For each element in resulting range assign it to 0.0 if corresponding element in input range is NaN else assign it to 1.0.

Returns: true if there is at least one NaN in input range [first, last).

Type Requirements:

InputIterator is Single Pass Iterator
InputIterator is Readable Iterator
std::isnan(*InputIterator) is a valid expression (e.g. float, double, and long double )
OutputIterator is Incrementable Iterator
OutputIterator is Writable Iterator
float is convertible to OutputIterator value type

Since: New in yat 0.5

void theplu::yat::utility::chdir ( const std::string & dir )

Same as C function chdir but throws on failure (instead of retrning non-zero).

Exceptions

runtime_error if underlying chdir returns non-zero

See Also: http://linux.die.net/man/3/chdir

Since: New in yat 0.10

template<class Iter >

void theplu::yat::utility::check_iterator_is_unweighted ( Iter iter )

check (at compile time) that iterator is unweighted.

This function only compiles if iterator iter is unweighted.

void theplu::yat::utility::chmod	(	const std::string &	filename,
		mode_t	mode
	)

same as C function chmod but throws on failure (instead of returning non-zero).

See Also: http://linux.die.net/man/3/chmod

Since: New in yat 0.10

template<typename T >

void theplu::yat::utility::clear ( std::vector< T > & vec )

reduce size and capacity to zero

The standard provides a member function clear(void), which clears the contents of the vector i.e. sets the size to zero. However, the member function might leave the capacity unchanged and sometimes, when it's desiribale to save memory usage e.g., it preferable to use this function, which reduces the capacity to zero.

Since: new in yat 0.13

template<typename T >

std::string theplu::yat::utility::convert ( T input )

convert T to a string

T is supposed to be a numerical type.

Since: new in yat 0.8

template<typename T >

T theplu::yat::utility::convert ( const std::string & s )

convert string to (numerical) type

Exceptions

runtime_error if conversion fails

void theplu::yat::utility::copy_file	(	const std::string &	source,
		const std::string &	target
	)

Copy file source to target.

Exceptions

runtime_error if read error of source or write error for target is encountered.

std::string theplu::yat::utility::dirname ( const std::string & fn )

Same as posix C function with same name but works on std::string rather than char*.

See Also: http://linux.die.net/man/3/dirname

Returns: everything prior last '/'.

Since: New in yat 0.10

bool theplu::yat::utility::fnmatch	(	const std::string &	pattern,
		const std::string &	str,
		int	flags = `0`
	)

Returns: true if str matches pattern

See Also: http://linux.die.net/man/3/fnmatch

Exceptions

runtime_error if returned value from underlying fnmatch is neither zero nor FNM_NOMATCH.

Since: New in yat 0.10

template<typename Key , typename Tp , typename Compare , typename Alloc , typename Key2 >

const Tp & theplu::yat::utility::get	(	const std::map< Key, Tp, Compare, Alloc > &	m,
		const Key2 &	k
	)

Same functionality as map::operator[] but the function does not modify the map and the function throws if key does not exist in the map.

Type Requirment:

Key2 is convertible to Key

Returns: const reference to m[k]

Exceptions

get_error if key k does not exist in map m

Since: New in yat 0.7

template<typename InputIterator , typename Key , typename Comp >

void theplu::yat::utility::inverse	(	InputIterator	first,
		InputIterator	last,
		std::map< Key, std::vector< size_t >, Comp > &	m
	)

Creating a map from a range [first, last) such that m[key] returns a vector with indices of which element in [first, last) that is equal to key, or more technically: m[element].size() returns number of elements equal to element, and m[*element][i] = distance(first, element) for every element in [first, last) and i smaller than m[element].size().

Requirement: InputIterator's value type is assignable to Key

Since: New in yat 0.5

template<typename Key , typename InputIterator , typename Comp >

void theplu::yat::utility::inverse	(	InputIterator	first,
		InputIterator	last,
		std::multimap< Key, size_t, Comp > &	m
	)

In the created multimap each element e will fulfill: $ *(first + e->second) == e->first $

Requirement: InputIterator's value type is assignable to Key

Since: New in yat 0.5

template<typename InputIterator , typename Key , typename Comp >

void theplu::yat::utility::inverse	(	InputIterator	first,
		InputIterator	last,
		std::map< Key, size_t, Comp > &	m
	)

Create a map mapping from values in range [first, last) to the distance from first.

Post-condition: m[first[i]] == i (for all i that correspond to a unique element). For non-unique element behaviour is undefined.

Requirement: InputIterator's value type is assignable to Key

Since: New in yat 0.10

template<typename T >

bool theplu::yat::utility::is ( const std::string & s )

check if string is convertible to (numerical) type T

Since: New in yat 0.5

bool theplu::yat::utility::is_double ( const std::string & )

Returns: true if string is a double

Deprecated:: Provided for backward compatibility with the 0.4 API. Use is<double>(const std::string&)

bool theplu::yat::utility::is_equal	(	std::string	s,
		std::string	other
	)

This function takes the first word (separated by whitespace) in s, replaces all upper case with lower case, and compares it with other.

Returns: true if processed s is equal to other. It returns false otherwise or if s contains more than one word.

bool theplu::yat::utility::is_float ( const std::string & )

Returns: true if string is a float

Deprecated:: Provided for backward compatibility with the 0.4 API. Use is<float>(const std::string&)

bool theplu::yat::utility::is_int ( const std::string & )

Returns: true if string is an int

Deprecated:: Provided for backward compatibility with the 0.4 API. Use is<int>(const std::string&)

bool theplu::yat::utility::is_nan ( const std::string & s )

Returns: true if string is "nan" (case-insensitive)

template<typename T >

void theplu::yat::utility::load	(	std::istream &	is,
		std::vector< std::vector< T > > &	vec,
		char	sep = `'\0'`,
		char	line_sep = `'\n'`,
		bool	ignore_empty = `false`,
		bool	rectangle = `true`
	)

The std::istream will be interpreted as outlined here:

Lines are separated by character line_sep and rows are separated by character sep.

The first line is read into a stringstream, which is used to load the first vector (vec[0]) with elements using load(stringstream, vec[0], sep).

Therefore, column elements separation has two modes depending on the value of sep.

If sep is the default '\0' value then column elements are separated with white space characters except the new line character. Multiple sequential white space characters are treated as one separator.
Setting sep to something else than the default value will change the behaviour to use the sep character as the separator between column elements. Multiple sequential sep characters will be treated as separating elements with missing values.

If rectangle is true, rows must contain same number of elements or function will throw.

If ignore_empty is true empty lines are ignored.

See Also: load(std::istream&, std::vector<T>&, char sep='\0')

Note: Requirement on T: utility::convert<T> must be supported (from yat 0.7 T=string is also supported)

Since: New in yat 0.6

template<typename T >

void theplu::yat::utility::load	(	std::istream &	is,
		std::vector< T > &	vec,
		char	sep = `'\0'`
	)

Fill a vector<T> with elements from istream.

Element separation has two modes depending on the value of sep.

If sep is the default '\0' value then elements are separated with white space characters. Multiple sequential white space characters are treated as one separator.
Setting sep to something else than the default value will change the behaviour to use the sep character as the separator between column elements. Multiple sequential sep characters will be treated as separating elements with missing values. Missing values are set to std::numeric_limits<T>::quiet_NaN

Note: Requirement on T: utility::convert<T> must be supported (from yat 0.7 T=string is also supported)

Since: New in yat 0.6

template<typename T >

T theplu::yat::utility::log2 ( T x )

Returns: base-2 logarithm of x

Implemented for float, double, and long double.

Since: New in yat 0.10

unsigned int theplu::yat::utility::major_version ( void )

Returns: major version number of compiled yat library

Since: New in yat 0.5

template<typename Pointer , class Compare >

compose_f_gx_hy<Compare, Dereferencer<Pointer>, Dereferencer<Pointer> > theplu::yat::utility::make_ptr_compare	(	Pointer	p,
		Compare	compare
	)

Convenient function that creates a binary predicate that can be used to compare pointers when you want to compare them with respect to the objects they point to.

Example:

std::vector<MyClass*> vec(18);
...
std::sort(vec.begin(), vec.end(),
          make_ptr_compare(vec[0], std::greater<MyClass>()));

Type Requirement:

compare must be a Adaptable Binary Predicate.
value_type of Pointer must be convertible to argument_type of compare

Returns: a compose_f_gx_hy in which F is defined by compare and both G and H are Dereferencer functors.

See Also: compose_f_gx_hy

Since: New in yat 0.7

template<typename Pointer >

compose_f_gx_hy<std::less<typename std::iterator_traits<Pointer>::value_type>, Dereferencer<Pointer>, Dereferencer<Pointer> > theplu::yat::utility::make_ptr_compare ( Pointer p )

Same as make_ptr_compare(2) except that std::less is used to compare pointers.

Since: New in yat 0.7

template<typename T >

T theplu::yat::utility::max	(	const T &	a,
		const T &	b,
		const T &	c
	)

Returns: max of values

template<typename T >

T theplu::yat::utility::max	(	const T &	a,
		const T &	b,
		const T &	c,
		const T &	d
	)

Returns: max of values

template<typename T >

T theplu::yat::utility::max	(	const T &	a,
		const T &	b,
		const T &	c,
		const T &	d,
		const T &	e
	)

Returns: max of values

template<typename T >

T theplu::yat::utility::max	(	const T &	a,
		const T &	b,
		const T &	c,
		const T &	d,
		const T &	e,
		const T &	f
	)

Returns: max of values

template<class Container2D >

void theplu::yat::utility::merge	(	const Container2D &	x,
		std::vector< std::string > &	labels,
		Matrix &	y
	)

merge rows in a Container2D

When two (or several) elements in labels are found, the corresponding rows in x are merged into one row vector. The vector of labels are modified to reflect the rows in the resulting container y. In this default implementation the merge is calculated as the (weighted) arithmetic mean.

x must be a Container2D and it works for both weighted and unweighted containers.

Parameters

x	input container to be merged.
labels	telling which rows to merge.
y	resulting merged container.

Note: If x and y overlap in their underlying data structures, the result is undefined.

Since: New in yat 0.6

template<class Container2D , class Functor >

void theplu::yat::utility::merge	(	const Container2D &	x,
		std::vector< std::string > &	labels,
		Matrix &	y,
		Functor	func
	)

merge rows in a Container2D using a Functor

Same as merge(const Container2D&, std::vector<std::string>&, Matrix&) but instead of calculating the merged element as the (weighted) arithmetic mean, the merged element is calculated as defined by func.

Parameters

x	input container to be merged.
labels	telling which rows to merge.
y	resulting merged container.
func	defines how data values are calculated

Functor func has an operator()(Iterator first, Iterator last) const that calculates the merged value from range [first, last).

Type Requirements:

Container2D is a Container2D
Functor is a Binary Function.
Container2D::const_column_iterator is convertible to argument types of Functor.
Return type of Functor is convertible to double

If Functor works on both unweighted and weighted iterators, merge works on both unweighted and weighted Container2D.

Note: If x and y overlap in their underlying data structures, the result is undefined.

Since: New in yat 0.6

template<class Container2D , class Functor1 , class Functor2 >

void theplu::yat::utility::merge	(	const Container2D &	x,
		std::vector< std::string > &	labels,
		MatrixWeighted &	y,
		Functor1	data_func,
		Functor2	weight_func
	)

merge rows in a Container2D to a MatrixWeighted

When two (or several) elements in labels are found, the corresponding rows in x are merged into one row vector. The vector of labels are modified to reflect the rows in the resulting container y.

The data value of each element is calculated as defined by data_func and and the weight value is calculated as defined by weight_func.

x must be a Container2D. If Functor1 and Functor2 work on both unweighted and weighted iterators, merge works on both unweighted and weighted Container2D.

Parameters

x	input container to be merged.
labels	telling which rows to merge.
y	resulting merged container.
data_func	defines how data values are calculated
weight_func	defines how weight values are calculated

Functor1 and Functor2 have an operator()(Iterator first, Iterator last) const that calculates the merged value and weight, respectively, from range [first, last).

Type Requirements:

Container2D is a Container2D
Functor1 is a Binary Function.
Functor2 is a Binary Function.
Container2D::const_column_iterator is convertible to argument types of Functor1 and Functor2.
Return type of Functor1 is convertible to double
Return type of Functor2 is convertible to double

If Functor1 and Functor2 work on both unweighted and weighted iterators, merge works on both unweighted and weighted Container2D.

Note: If x and y overlap in their underlying data structures, the result is undefined.

Since: New in yat 0.6

unsigned int theplu::yat::utility::minor_version ( void )

Returns: minor version number of compiled yat library

Since: New in yat 0.5

void theplu::yat::utility::mkdir	(	const std::string &	dir,
		mode_t	mode = `0777`
	)

create a directory dir

See Also: http://linux.die.net/man/3/mkdir

Exceptions

runtime_error if creation failed

Since: New in yat 0.10

void theplu::yat::utility::mkdir_p	(	const std::string &	dir,
		mode_t	mode = `0777`
	)

No error if dir already exist. Make parent directories as needed.

Since: New in yat 0.10

double theplu::yat::utility::NeedlemanWunsch	(	const utility::Matrix &	s,
		std::vector< std::pair< size_t, size_t > > &	path,
		const double	gap
	)

Function performing alignment following the Needleman-Wunch algorithm. The algorithm starts from the dot-matrix, s, where $s_{ij}$ describes how well element $ i $ in the first sequence match to element $ j $ in the second sequence. A path through this matrix corresponds to an alignment of the two sequences, in which a diagonal step over a matrix element corresponds to a match between the corresponding sequnce elements and a vertical or a horizontal step corresponds to inserting a gap in one of the sequnces. The function maximizes $\sum s_{ij}-n$ gap, where the first sum goes over all matches and the second term is a penalty term for inserting $ n $ gaps. Default is to have the gap cost set to zero. The vector path contains information about which elements that were matched. If the first element in the first sequence was matched to the first element in the second sequence, the last element in path is pair(0,0).