yat  0.16pre
Classes | Typedefs | Functions
theplu::yat::utility Namespace Reference

Miscellaneous functionality. More...

Classes

class  Aligner
 Aligning two sequences. More...
 
class  BasicMatrix
 
class  BasicVector
 
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  DiagonalMatrix
 Diagonal Matrix. 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  MatrixExpression
 An expression that can be converted to a 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  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  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<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 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 >
max (const T &a, const T &b, const T &c)
 
template<typename T >
max (const T &a, const T &b, const T &c, const T &d)
 
template<typename T >
max (const T &a, const T &b, const T &c, const T &d, const T &e)
 
template<typename 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 >
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)
 
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 >
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

Since
New in yat 0.6
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:

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_errorif 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 ( 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_errorif conversion fails
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
void theplu::yat::utility::copy_file ( const std::string &  source,
const std::string &  target 
)

Copy file source to target.

Exceptions
runtime_errorif 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_errorif 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_errorif key k does not exist in map m
Since
New in yat 0.7
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
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
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 iff lhs is inluded in rhs
Since
New in yat 0.15
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 ( 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:

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 >
Segment<T> theplu::yat::utility::make_segment ( first,
last 
)
Returns
Segment<T>
Since
ney in yat 0.15
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
xinput container to be merged.
labelstelling which rows to merge.
yresulting 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
xinput container to be merged.
labelstelling which rows to merge.
yresulting merged container.
funcdefines 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:

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
xinput container to be merged.
labelstelling which rows to merge.
yresulting merged container.
data_funcdefines how data values are calculated
weight_funcdefines 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:

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_errorif creation failed
Since
New in yat 0.10
void theplu::yat::utility::mkdir_p ( const std::string &  dir,
mode_t  mode = 0777 
)

Similar to mkdir(const std::string&, mode_t).

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

Returns
the global maximum alignment score.
See Also
Aligner
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
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
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
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
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
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
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 iff lhs and rhs overlap
Since
New in yat 0.15
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
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
unsigned int theplu::yat::utility::patch_version ( void  )
Returns
patch version number of compiled yat library
Since
New in yat 0.5
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
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
void theplu::yat::utility::replace ( std::string &  full_str,
std::string  old_str,
std::string  new_str 
)

In full_str replace every sub-string old_str with new_str;

Since
New in yat 0.10
void theplu::yat::utility::shuffle ( VectorMutable &  invec)

Randomly shuffles the elements in VectorMutable invec

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
sscore matrix in which element $(i,j)$ is the score between element $i$ in first sequence and element $j$ in second sequence.
gapcost for having a gap (insertion or deletion)
open_gapcost 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.
void theplu::yat::utility::sort ( VectorMutable &  vec)

Sort the elements in the VectorMutable vec

NaNs are treated as infinity

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:

Since
New in yat 0.5. In versions prior 0.13 function was restricted to Forward Iterator with value_type convertible to double.
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:

Since
New in yat 0.13
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.

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.

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.

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

Since
New in yat 0.13
std::string theplu::yat::utility::version ( void  )
Returns
version number of compiled yat library
Since
New in yat 0.5

Generated on Mon Oct 16 2017 02:22:40 for yat by  doxygen 1.8.5