Miscellaneous functionality. More...

Classes
struct	abs

class	Aligner
	Aligning two sequences. More...

class	BasicMatrix

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

class	BasicVector

class	BFGS

class	BFGS2

class	BinaryIstreamIterator

class	BinaryOstreamIterator

class	Bisection

class	Brent

class	BrentMinimizer

class	CigarIterator
	Iterator over a CIGAR. More...

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

class	ColumnStream

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

class	compose_f_gx

class	compose_f_gx_hx

class	compose_f_gx_hy

class	compose_f_gxy

class	Container2D
	Concept check for Container2D. More...

class	Container2DIterator
	Iterator for a Container2D. More...

class	DataIterator
	DataIterator. More...

class	DataIteratorConcept
	Concept check for Data Iterator. 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...

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

class	DiagonalMatrix
	Diagonal Matrix. More...

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

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

struct	Exp

class	FalsePosition

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

class	FletcherReevesConjugate

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

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

class	GoldenSection

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

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

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

class	invalid_argument
	Class used for all invalid arguments detected within yat library. More...

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

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...

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

class	Matrix
	Interface to GSL matrix. More...

class	MatrixBase

class	MatrixConstView

class	MatrixExpression
	An expression that can be converted to a Matrix. More...

class	MatrixMutable

class	MatrixView
	Interface to GSL matrix_view. More...

class	MatrixWeighted
	Weighted Matrix. More...

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

class	Minimizer
	Wrapper class around gsl_min_fminimizer in GSL. More...

class	MultiMinimizer
	Wrapper class around gsl_multimin_fminimizer in GSL. More...

class	MultiMinimizerDerivative
	Wrapper class around gsl_multimin_fdfminimizer in GSL. More...

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

class	NelderMeadSimplex

class	NelderMeadSimplex2

class	NelderMeadSimplex2Rand

class	Newton

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	OptionHelp
	Class for help option. More...

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

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

class	OptionSwitch
	Class for switch option. More...

class	OptionVersion
	Class for version option. More...

class	OstreamIterator

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	PCA
	Principal Component Analysis. More...

class	PolakRibiereConjugate

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

class	QuadGolden

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

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

class	Ranking

class	RootFinder

class	RootFinderDerivative

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

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

class	Secant

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	SortedBuffer

class	SteepestDescent

class	Steffenson

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

class	SVD
	Singular Value Decomposition. More...

class	TrivialIterator
	Concept check for Trivial Iterator. More...

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

struct	unweighted_iterator_tag

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	VectorExpression
	An expression that can be converted to a Vector. 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	weighted_if_any2

struct	weighted_if_any3

struct	weighted_iterator_tag

struct	weighted_iterator_traits

class	WeightedIterator
	WeightedIterator. More...

class	WeightedIteratorArchetype

struct	WeightedIteratorArchetype_ctor_arg

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 MatrixBase &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 T >
expression::ScaledMatrix< T >	operator* (const BasicMatrix< MatrixExpression< expression::ScaledMatrix< T > > > &A, double k)

template<class T >
expression::ScaledMatrix< T >	operator* (double k, const BasicMatrix< MatrixExpression< expression::ScaledMatrix< T > > > &A)

template<class T >
expression::ScaledMatrix< T >	operator- (const BasicMatrix< MatrixExpression< expression::ScaledMatrix< T > > > &A)

int8_t	cigar_table (unsigned char c)

template<typename T >
std::istream &	getvector (std::istream &is, std::vector< T > &result, char delim, char newlinedelim='\n')

template<typename T >
std::istream &	getvector (std::istream &is, std::vector< T > &result, const std::string &delim, char newlinedelim='\n')

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

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 , typename OutputIterator , class Function , class Compare >
void	multiprocess (InputIterator begin, InputIterator end, OutputIterator out, size_t cap1, size_t n_threads, size_t cap2, Function function, Compare compare)

template<typename InputIterator , typename OutputIterator , class Function >
void	multiprocess (InputIterator begin, InputIterator end, OutputIterator out, size_t cap1, size_t n_threads, size_t cap2, Function function)

template<typename InputIterator , typename ForwardIterator >
void	round (InputIterator first, InputIterator last, ForwardIterator result)
	Round a range. More...

template<typename T >
Segment< T >	make_segment (T first, T last)

template<typename T , class Compare >
bool	includes (const yat::utility::Segment< T, Compare > &lhs, const yat::utility::Segment< T, Compare > &rhs)

template<typename T , class Compare >
bool	overlap (const yat::utility::Segment< T, Compare > &lhs, const yat::utility::Segment< T, Compare > &rhs)

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 T >
std::istream &	binary_read (std::istream &is, T &x)

template<typename T >
void	binary_write (std::ostream &os, T x)

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 charT , class Traits , class Allocator >
bool	contains (const std::basic_string< charT, Traits, Allocator > &str, const std::basic_string< charT, Traits, Allocator > &substr)

template<typename charT , class Traits , class Allocator >
bool	contains (const std::basic_string< charT, Traits, Allocator > &str, charT substr)
	since New in yat 0.20

template<typename charT , class Traits , class Allocator >
bool	contains (const std::basic_string< charT, Traits, Allocator > &str, const charT *substr)
	since New in yat 0.20

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...

template<typename T >
bool	convert_try (const std::string &s, T &t)
	try to convert 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)

template<typename charT , class Traits , class Allocator >
bool	ends_with (const std::basic_string< charT, Traits, Allocator > &str, const std::basic_string< charT, Traits, Allocator > &suffix)

template<typename charT , class Traits , class Allocator >
bool	ends_with (const std::basic_string< charT, Traits, Allocator > &str, charT suffix)
	since New in yat 0.20

template<typename charT , class Traits , class Allocator >
bool	ends_with (const std::basic_string< charT, Traits, Allocator > &str, const charT *suffix)
	since New in yat 0.20

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

std::string	getcwd (void)
	current directory More...

void	gsl_error_handler (const char reason, const char file, int line, int gsl_errno)

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	print_what (const std::exception &error, std::ostream &out=std::cerr)
	recursively print exception what More...

void	remove (const std::string &fn)

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

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

template<typename charT , class Traits , class Allocator >
bool	starts_with (const std::basic_string< charT, Traits, Allocator > &str, const std::basic_string< charT, Traits, Allocator > &prefix)

template<typename charT , class Traits , class Allocator >
bool	starts_with (const std::basic_string< charT, Traits, Allocator > &str, charT prefix)
	since New in yat 0.20

template<typename charT , class Traits , class Allocator >
bool	starts_with (const std::basic_string< charT, Traits, Allocator > &str, const charT *prefix)
	since New in yat 0.20

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

void	symlink (const std::string &path1, const std::string &path2)

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

◆ StreamRedirect

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

Since: New in yat 0.6

◆ wStreamRedirect

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

Since: New in yat 0.6

Function Documentation

◆ basename()

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

◆ binary_read()

template<typename T >

std::istream& theplu::yat::utility::binary_read	(	std::istream &	is,
		T &	x
	)

Read data from is into variable x. Data has typically been written with binary_write(std::ostream& os, T).

T is expected to be a native numerical type.

Returns: is

Since: New in yat 0.18

◆ binary_weight()

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

◆ binary_write()

template<typename T >

void theplu::yat::utility::binary_write	(	std::ostream &	os,
		T	x
	)

Write value of x into ostream os in binary format. Since the data is written in the native binary format, it may not be portable between different architectures.

T is expected to be a native numerical type.

See also: binary_read(std::istream&, T&)

Since: New in yat 0.18

◆ chdir()

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

◆ check_iterator_is_unweighted()

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.

◆ chmod()

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

◆ cigar_table()

int8_t theplu::yat::utility::cigar_table ( unsigned char c )

The inverse of BAM_CIGAR_STR[x], where BAM_CIGAR_STR is "MIDNSHP=XB".

Exceptions

if	input is not one of "MIDNSHP=XB".

Since: New in yat 0.19

◆ clear()

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

◆ contains()

template<typename charT , class Traits , class Allocator >

bool theplu::yat::utility::contains	(	const std::basic_string< charT, Traits, Allocator > &	str,
		const std::basic_string< charT, Traits, Allocator > &	substr
	)

Returns: true if string str contains s

See also: https://en.cppreference.com/w/cpp/string/basic_string/comtains

Since: New in yat 0.20

◆ convert() [1/2]

template<typename T >

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

convert T to a string

T is supposed to be a numerical type.

See also: std::to_string in C++11

Since: new in yat 0.8

◆ convert() [2/2]

template<typename T >

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

convert string to (numerical) type

Exceptions

runtime_error if conversion fails

◆ convert_try()

template<typename T >

bool theplu::yat::utility::convert_try	(	const std::string &	s,
		T &	t
	)

try to convert

See also: is<T>; convert<T>

Returns: true if conversion was successful

Since: new in yat 0.15

◆ copy_file()

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.

◆ dirname()

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

◆ ends_with()

template<typename charT , class Traits , class Allocator >

bool theplu::yat::utility::ends_with	(	const std::basic_string< charT, Traits, Allocator > &	str,
		const std::basic_string< charT, Traits, Allocator > &	suffix
	)

Returns: true if string str ends with suffix

See also: https://en.cppreference.com/w/cpp/string/basic_string/ends_with

Since: New in yat 0.20

◆ fnmatch()

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

◆ get()

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

Similar to std::map::at(const Key& ) in c++11.

Since: New in yat 0.7

◆ getcwd()

std::string theplu::yat::utility::getcwd ( void )

current directory

See also: https://linux.die.net/man/3/getcwd

Since: New in yat 0.17

◆ getvector() [1/2]

template<typename T >

std::istream & theplu::yat::utility::getvector	(	std::istream &	is,
		std::vector< T > &	result,
		char	delim,
		char	newlinedelim = `'\n'`
	)

Read all elements is is until newlinedelim or end of stream. Elements seprated by delim are split and push_backed in result. If T is not std::string, elements are converted to T using convert<T>.

See also: convert<T>(const std::string&); split(std::string, const std::string&, char delim)

Since: New in yat 0.15

Returns: is

◆ getvector() [2/2]

template<typename T >

std::istream & theplu::yat::utility::getvector	(	std::istream &	is,
		std::vector< T > &	result,
		const std::string &	delim,
		char	newlinedelim = `'\n'`
	)

Same as getvector(std::istream&, std::vector<T>&, char, char) but elements are delimited with either character in delim.

Since: New in yat 0.15

◆ gsl_error_handler()

void theplu::yat::utility::gsl_error_handler	(	const char *	reason,
		const char *	file,
		int	line,
		int	gsl_errno
	)

Function can be used as argument to gsl_set_error_handler, so it is called when by GSL when an error is detected. This will result in a GSL_error is thrown.

See also: https://www.gnu.org/software/gsl/doc/html/err.html

Since: New in yat 0.18

◆ includes()

template<typename T , class Compare >

bool theplu::yat::utility::includes	(	const yat::utility::Segment< T, Compare > &	lhs,
		const yat::utility::Segment< T, Compare > &	rhs
	)

Return true if (and only if) lhs.begin is not less than rhs.begin and rhs.begin is not less than lhs.end

Returns: true if lhs is inluded in rhs

Since: New in yat 0.15

◆ inverse() [1/3]

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

◆ inverse() [2/3]

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

◆ inverse() [3/3]

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

◆ is()

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

◆ is_double()

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&)

◆ is_equal()

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.

◆ is_float()

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&)

◆ is_int()

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&)

◆ is_nan()

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

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

◆ load() [1/2]

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

◆ load() [2/2]

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

◆ log2()

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

◆ major_version()

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

Returns: major version number of compiled yat library

Since: New in yat 0.5

◆ make_ptr_compare() [1/2]

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

◆ make_ptr_compare() [2/2]

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

◆ make_segment()

template<typename T >

Segment<T> theplu::yat::utility::make_segment	(	T	first,
		T	last
	)

Returns: Segment<T>

Since: ney in yat 0.15

◆ max() [1/4]

template<typename T >

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

Returns: max of values

◆ max() [2/4]

template<typename T >

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

Returns: max of values

◆ max() [3/4]

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

◆ max() [4/4]

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

◆ merge() [1/3]

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

◆ merge() [2/3]

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

◆ merge() [3/3]

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

◆ minor_version()

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

Returns: minor version number of compiled yat library

Since: New in yat 0.5

◆ mkdir()

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

◆ mkdir_p()

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

◆ multiprocess() [1/2]

template<typename InputIterator , typename OutputIterator , class Function , class Compare >

void theplu::yat::utility::multiprocess	(	InputIterator	begin,
		InputIterator	end,
		OutputIterator	out,
		size_t	cap1,
		size_t	n_threads,
		size_t	cap2,
		Function	function,
		Compare	compare
	)

Same as multiprocess(begin, end, out, cap1, n_threads, cap2, function) but use compare instead of std::less<T>

Since: New in yat 0.19

◆ multiprocess() [2/2]

template<typename InputIterator , typename OutputIterator , class Function >

void theplu::yat::utility::multiprocess	(	InputIterator	begin,
		InputIterator	end,
		OutputIterator	out,
		size_t	cap1,
		size_t	n_threads,
		size_t	cap2,
		Function	function
	)

Function reads the sorted range [begin, end), applies function on each element and if function returns true, element is copied into out and out is incremented.

This is done in n_threads + 2 threads. The reading of element from the sorted range is done in one range, the calling of function is done in n_threads threads, and the merging of the results from those calls and copying to out is done in one thread.

The communication between the threads are done in buffer containers and to avoid extreme memory usage, the sizes of these containers can be capped with parameter cap1 and cap2. There's a single container communicating between reader thread and worker threads, and cap1 limits the size of the container. Each worker has a container communicating with the writer thread, so there are n_threads such containers and the size of each container is limited by cap2.

Since: new in yat 0.19

◆ NeedlemanWunsch()

double theplu::yat::utility::NeedlemanWunsch	(	const MatrixBase &	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).

Returns: the global maximum alignment score.

See also: Aligner

◆ operator!=()

template<typename T1 , typename T2 >

bool theplu::yat::utility::operator!=	(	const Range< T1 > &	lhs,
		const Range< T2 > &	rhs
	)

Based on operator==.

Since: New in yat 0.5

◆ operator*() [1/2]

template<class T >

expression::ScaledMatrix<T> theplu::yat::utility::operator*	(	const BasicMatrix< MatrixExpression< expression::ScaledMatrix< T > > > &	A,
		double	k
	)

Specialization for ScaledMatrix

Since: New in yat 0.18

◆ operator*() [2/2]

template<class T >

expression::ScaledMatrix<T> theplu::yat::utility::operator*	(	double	k,
		const BasicMatrix< MatrixExpression< expression::ScaledMatrix< T > > > &	A
	)

Specialization for ScaledMatrix

Since: New in yat 0.18

◆ operator-()

template<class T >

expression::ScaledMatrix<T> theplu::yat::utility::operator- ( const BasicMatrix< MatrixExpression< expression::ScaledMatrix< T > > > & A )

Specialization for ScaledMatrix

Since: New in yat 0.18

◆ operator<()

template<typename T1 , typename T2 >

bool theplu::yat::utility::operator<	(	const Range< T1 > &	lhs,
		const Range< T2 > &	rhs
	)

Ordering relation.

Using std::lexicographical_compare

Returns: true if lhs < rhs

Since: New in yat 0.5

◆ operator<=()

template<typename T1 , typename T2 >

bool theplu::yat::utility::operator<=	(	const Range< T1 > &	lhs,
		const Range< T2 > &	rhs
	)

Returns: ! (rhs < lhs )

Since: New in yat 0.5

◆ operator==()

template<typename T1 , typename T2 >

bool theplu::yat::utility::operator==	(	const Range< T1 > &	lhs,
		const Range< T2 > &	rhs
	)

Equality comparison.

Returns: true iff underlying elements are equal

Since: New in yat 0.5

◆ operator>()

template<typename T1 , typename T2 >

bool theplu::yat::utility::operator>	(	const Range< T1 > &	lhs,
		const Range< T2 > &	rhs
	)

Returns: rhs < lhs

Since: New in yat 0.5

◆ operator>=()

template<typename T1 , typename T2 >

bool theplu::yat::utility::operator>=	(	const Range< T1 > &	lhs,
		const Range< T2 > &	rhs
	)

Returns: ! (lhs < rhs )

Since: New in yat 0.5

◆ overlap()

template<typename T , class Compare >

bool theplu::yat::utility::overlap	(	const yat::utility::Segment< T, Compare > &	lhs,
		const yat::utility::Segment< T, Compare > &	rhs
	)

Return true if lhs is not less than rhs and rhs is not less than lhs

Returns: true if lhs and rhs overlap

Since: New in yat 0.15

◆ pair_first_iterator()

template<class Iter >

boost::transform_iterator< PairFirst<typename boost::remove_reference< typename std::iterator_traits<Iter>::reference >::type>, Iter> theplu::yat::utility::pair_first_iterator ( Iter i )

Creates a transform_iterator that transforms an iterator with value type std::pair to an iterator with value type std::pair::first_type. This can be used, for example, to communicate between a std::map and std::vector

std::map<std::string, int> map;
...
std::vector<std::string> vec;
vec.resize(map.size());
std::copy(pair_first_iterator(map.begin()), pair_first_iterator(map.end()),
          vec.begin());

Since: New in yat 0.5

◆ pair_second_iterator()

template<class Iter >

boost::transform_iterator< PairSecond<typename boost::remove_reference< typename std::iterator_traits<Iter>::reference >::type>, Iter> theplu::yat::utility::pair_second_iterator ( Iter i )

Creates a transform_iterator that transforms an iterator with value type std::pair to an iterator with value type std::pair::second_type. This can be used, for example, to communicate between a std::map and std::vector

std::map<std::string, int> map;
...
std::vector<int> vec(map.size(),0);
std::copy(vec.begin(), vec.end(), pair_second_iterator(map.begin()));

Since: New in yat 0.5

◆ patch_version()

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

Returns: patch version number of compiled yat library

Since: New in yat 0.5

◆ print_what()

void theplu::yat::utility::print_what	(	const std::exception &	error,
		std::ostream &	out = `std::cerr`
	)

recursively print exception what

Print what() of error to out. If error is nested, the exception that is nested in error is passed to print_what().

Note: If nested exception is null, function calls terminate (this behaviour might change in the future).

Since: new in yat 0.16

◆ remove()

void theplu::yat::utility::remove ( const std::string & fn )

same as C function remove but throws errno_error at failure

See also: http://linux.die.net/man/3/remove

Since: New in yat 0.12

◆ rename()

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

same as C function with same name but throws errno_error if error is encountered

See also: http://linux.die.net/man/3/rename

Since: New in yat 0.12

◆ replace()

void theplu::yat::utility::replace	(	std::string &	full_str,
		const std::string &	old_str,
		const std::string &	new_str
	)

In full_str replace every sub-string old_str with new_str;

Since: New in yat 0.10

See also: boost::algorithm::replace_all(string&, const string&, const string&)

◆ round()

template<typename InputIterator , typename ForwardIterator >

void theplu::yat::utility::round	(	InputIterator	first,
		InputIterator	last,
		ForwardIterator	result
	)

Round a range.

Round each element in [first, last) to the neighboring integer, such that the total difference is minimised, but with the condition that the sum of elements in [result, result+(last-first)) is equal to the sum of elements in the input range [first, last).

It is possible to round "in place"; it is permissible for first and result to point to the same value.

Since: New in yat 0.19

◆ shuffle()

void theplu::yat::utility::shuffle ( VectorMutable & invec )

Randomly shuffles the elements in VectorMutable invec

◆ SmithWaterman()

double theplu::yat::utility::SmithWaterman	(	const utility::Matrix &	s,
		double	gap,
		double	open_gap
	)

Local alignment following the Smith-Waterman algorithm.

Instead of looking at each sequence in its entirety the S-W algorithm compares segment of all possible lengths (LOCAL alignment) and chooses whichever maximises the similarity measure.

Returns: the similarity score that maximizes $\sum_{i,j} A_{ij}s_{ij} - L*gap - N*open\textunderscore gap$ , where $A_{ij}$ is unity if element i in first sequence is aligned against element j in second sequence (zero otherwise); L is total length of gaps; and N is number of gaps.

Parameters

s	score matrix in which element is the score between element in first sequence and element in second sequence.
gap	cost for having a gap (insertion or deletion)
open_gap	cost for open up a gap in sequence, in other words, for a gap of length L the total cost is open_gap + L*gap.

Deprecated:: Provided for backward compatibility with 0.8 API. Use Aligner::smith_waterman() instead.

◆ sort()

void theplu::yat::utility::sort ( VectorMutable & vec )

Sort the elements in the VectorMutable vec

NaNs are treated as infinity

◆ sort_index() [1/3]

template<typename InputIterator >

void theplu::yat::utility::sort_index	(	InputIterator	first,
		InputIterator	last,
		std::vector< size_t > &	sort_index
	)

Create a vector sort_index containing the indeces of elements in a range [first, last). The elements of sort_index give the index of the range element which would have been stored in that position if the range had been sorted in place. The first element of sort_index gives the index of the least element in the range, and the last element of sort_index gives the index of the greatest element in the range. The function will not affect the range, i.e., InputIterator can be read-only.

Type Requirements:

InputIterator is a model of Input Iterator
InputIterator::value_type is LessThan Comparable
Either InputIterator::value_type is Default Constructible or InputIterator is Random Access Traversal Iterator.
InputIterator::value_type is Assignable

Since: New in yat 0.5. In versions prior 0.13 function was restricted to Forward Iterator with value_type convertible to double.

◆ sort_index() [2/3]

template<typename InputIterator , class Compare >

void theplu::yat::utility::sort_index	(	InputIterator	first,
		InputIterator	last,
		std::vector< size_t > &	sort_index,
		Compare	comp
	)

Same as sort_index(InputIterator, InputIterator,std::vector<size_t>&), but objects are compared with comp rather than with operator<.

Type Requirements:

InputIterator is a model of Input Iterator
Either InputIterator::value_type is Default Constructible or InputIterator is Random Access Traversal Iterator.
Either InputIterator::value_type is Assignable or InputIterator is Random Access Traversal Iterator.
Compare is a model of Strict Weak Ordering
Compare is Copy Constructible
InputIterator::value_type is convertible to Compare's argument type

Since: New in yat 0.13

◆ sort_index() [3/3]

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

Create a vector sort_index containing the indeces of elements in a another VectorBase invec. The elements of sort_index give the index of the VectorBase element which would have been stored in that position if the VectorBase had been sorted in place. The first element of sort_index gives the index of the least element in invec, and the last element of sort_index gives the index of the greatest element in invec . The VectorBase invec is not changed.

◆ sort_largest_index()

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

Similar to sort_index but creates a VectorBase with indices to the k largest elements in invec.

◆ sort_smallest_index()

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

Similar to sort_index but creates a VectorBase with indices to the k smallest elements in invec.

◆ split() [1/2]

void theplu::yat::utility::split	(	std::vector< std::string > &	result,
		const std::string &	str,
		char	delim
	)

split a string into several substrings

Split str with respect to delim and place result in result. If str contains N delim, the resulting result will hold N+1 elements (given that it was empty to start with). If first or last character in str is delim, corresponding element in result will be empty string ("").

Since: New in yat 0.7

◆ split() [2/2]

void theplu::yat::utility::split	(	std::vector< std::string > &	result,
		const std::string &	str,
		const std::string &	delim
	)

split a string into substrings

Same as void split(std::vector<std::string>&, const std::string&,char delim); but split if character matches any in delims, i.e., split(vec,"split,me;please", ",;") will be split into "split", "me", and "please".

Since: New in yat 0.10

◆ ssearch()

double theplu::yat::utility::ssearch	(	std::string	first,
		std::string	second,
		double	gap,
		double	open_gap,
		double	mismatch = `0.0`
	)

SSearch does a rigorous Smith-Waterman search for similarity between sequences. For long sequences this may be very expensive (both in time and space) and BLAST or FASTA is preferable.

Function calculates a score matrix with elements $s_{ij}$ equal 1.0 when first[i] == second[j] and minus mismatch otherwise.

Returns: SmithWaterman score

Since: parameter mismatch available since yat 0.9

See also: Aligner

◆ starts_with()

template<typename charT , class Traits , class Allocator >

bool theplu::yat::utility::starts_with	(	const std::basic_string< charT, Traits, Allocator > &	str,
		const std::basic_string< charT, Traits, Allocator > &	prefix
	)

Returns: true if string str starts with prefix

See also: https://en.cppreference.com/w/cpp/string/basic_string/starts_with

Since: New in yat 0.20

◆ sum_weight()

template<typename Iterator >

double theplu::yat::utility::sum_weight	(	Iterator	first,
		Iterator	last
	)

Calculate sum of weights in range [first, last). The complexity is linear except in the important case when Iterator is unweighted and Random Access Iterator when complexity is constant.

Type Requirments:

Iterator is Data Iterator
Iterator is Readable Iterator
Iterator is Single Pass Iterator

Since: New in yat 0.13

◆ symlink()

void theplu::yat::utility::symlink	(	const std::string &	path1,
		const std::string &	path2
	)

same as C function symlink but throws errno_error at failure

Creates a symbolic link called path2 that contains the string pointed to by path1

See also: http://linux.die.net/man/3/symlink

Since: New in yat 0.16

◆ version()

std::string theplu::yat::utility::version ( void )

Returns: version number of compiled yat library

Since: New in yat 0.5

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ StreamRedirect

◆ wStreamRedirect

Function Documentation

◆ basename()

◆ binary_read()

◆ binary_weight()

◆ binary_write()

◆ chdir()

◆ check_iterator_is_unweighted()

◆ chmod()

◆ cigar_table()

◆ clear()

◆ contains()

◆ convert() [1/2]

◆ convert() [2/2]

◆ convert_try()

◆ copy_file()

◆ dirname()

◆ ends_with()

◆ fnmatch()

◆ get()

◆ getcwd()

◆ getvector() [1/2]

◆ getvector() [2/2]

◆ gsl_error_handler()

◆ includes()

◆ inverse() [1/3]

◆ inverse() [2/3]

◆ inverse() [3/3]

◆ is()

◆ is_double()

◆ is_equal()

◆ is_float()

◆ is_int()

◆ is_nan()

◆ load() [1/2]

◆ load() [2/2]

◆ log2()

◆ major_version()

◆ make_ptr_compare() [1/2]

◆ make_ptr_compare() [2/2]

◆ make_segment()

◆ max() [1/4]

◆ max() [2/4]

◆ max() [3/4]

◆ max() [4/4]

◆ merge() [1/3]

◆ merge() [2/3]

◆ merge() [3/3]

◆ minor_version()

◆ mkdir()

◆ mkdir_p()

◆ multiprocess() [1/2]

◆ multiprocess() [2/2]

◆ NeedlemanWunsch()

◆ operator!=()

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator-()

◆ operator<()

◆ operator<=()

◆ operator==()

◆ operator>()

◆ operator>=()

◆ overlap()

◆ pair_first_iterator()

◆ pair_second_iterator()

◆ patch_version()

◆ print_what()

◆ remove()

◆ rename()

◆ replace()

◆ round()

◆ shuffle()

◆ SmithWaterman()