Classes
class	Aligner
	Implements locarna alignment algorithm. More...

class	AlignerImpl
	Implementation of Aligner. More...

class	AlignerN
	Implements SPARSE, next generation alignment algorithm for locarna. More...

class	AlignerNParams
	parameters for AlignerN More...

class	AlignerP
	Computes partition function of alignment, arc match and base match probabilities. More...

class	AlignerParams
	Parameter for alignment by Aligner. More...

class	AlignerPParams
	parameters for AlignerP More...

class	AlignerRestriction
	Restricts range of an alignment in Aligner. More...

class	Alignment
	Represents a structure-annotated sequence alignment. More...

class	AlignmentEdges
	pair of vector of alignment edges More...

class	AlignmentImpl
	Implementation of Alignment. More...

class	Alphabet
	Specifies an alphabet. More...

class	AnchorConstraints
	Represents anchor constraints between two sequences. More...

class	ArcMatch
	Represents a match of two base pairs (arc match) More...

class	ArcMatches
	Maintains the relevant arc matches and their scores. More...

class	ArcMatchesIndexed
	class ArcMatches with additional mapping More...

class	BasePairs
	Describes sequence and structure ensemble of an RNA. More...

class	BasePairs__Arc
	Represents a base pair. More...

class	ConfusionMatrix
	Compare RNA secondary structure by their confusion matrix. More...

class	DiscreteDistribution

class	EdgeEnd
	end of an alignment edge More...

class	EPM
	a class for the representation of exact pattern matches (EPM) More...

class	ExactMatcher
	Computes exact pattern matchings (EPM) between two RNA sequences. More...

class	ExtRnaData
	represent sparsified data of RNA ensemble extended by in loop probabilities More...

class	ExtRnaDataImpl
	Implementation of ExtRnaData. More...

class	failure
	Simple exception class that supports a text message. More...

class	FiniteInt

class	FitOnOff
	Implements fitting of a two-step function to a number sequence. More...

class	FreeEndgapsDescription
	Description of free end gaps. More...

class	Gap
	"enum class" of gaps in alignment edges More...

class	greater_second
	Implements comparison by member second. More...

class	InftyInt

class	LCSEPM
	computes the best chain of EPMs, the LCS-EPM More...

class	MatchController
	abstract class that declares the method is_valid_match() More...

class	MatchProbs
	Provides probabilities for each match. More...

class	Matrix
	simple 2D matrix class, provides access via operator (int,int) More...

class	McC_ali_matrices_t
	Alifold-McCaskill matrices. More...

class	McC_matrices_base

class	McC_matrices_t
	McCaskill matrices. More...

class	MultipleAlignment
	Represents a multiple alignment. More...

class	OMatrix
	Simple matrix class with offset. More...

struct	option_def
	Definition structure of an option. More...

struct	pair_of_size_t_hash
	Function class definining hash function for pairs of size_t. More...

class	PatternPair
	is able to manage an EPM, consists of 2 singlepatterns, one in each RNA More...

class	PatternPairMap
	manage a set of EPMs (PatternPair) More...

class	PFoldParams
	Parameters for partition folding. More...

class	plusvector
	Implements a vector with += operator. More...

class	quadruple
	Represents a 4-tuple. More...

class	quintuple
	Represents a 5-tuple. More...

class	Ribofit
	Family of Ribofit matrices. More...

class	Ribofit_will2014

class	Ribosum
	Represents ribosum similarity matrices. More...

class	RibosumFreq
	Represents ribosum similarity matrices including raw frequencies. More...

class	RMatrix
	Simple matrix class with restriction to a range. More...

class	RnaData
	represent sparsified data of RNA ensemble More...

class	RnaDataImpl
	Implementation of RnaData. More...

class	RnaEnsemble
	Represents the raw structure ensemble data for an RNA. More...

class	RnaEnsembleImpl
	Implementation of RnaEnsemble. More...

class	RnaStructure
	An RNA secondary structure. More...

class	RotMatrix
	A matrix class with rotation. More...

class	Scoring
	Provides methods for the scoring of alignments. More...

class	ScoringParams
	Parameters for scoring. More...

class	Sequence
	"Sequence View" of multiple alignment as array of column vectors More...

class	SequenceAnnotation
	Annotation of a sequence. More...

class	SinglePattern
	stores a Pattern in one sequence More...

class	SparseMatrix
	Represents a sparse 2D matrix. More...

class	SparseTraceController
	combines the TraceController with the Mapper for both sequences More...

class	SparseVector
	Represents a sparse vector. More...

class	SparsificationMapper
	Represents the mapping for sparsification. More...

class	StopWatch
	control a set of named stop watch like timers More...

class	StralScore
	Implements the stral-like scoring function. More...

class	string1
	A simple 1-based string. More...

struct	syntax_error_failure
	thrown, when the format is recognized but syntax is incorrect More...

class	TaintedInftyInt

class	TraceController
	Controls the matrix cells valid for traces. More...

class	TraceRange
	Represents a range of traces. More...

class	triple
	Represents a 3-tuple. More...

class	type_wrapper
	generic type_wrapper class More...

struct	unordered_map

struct	unordered_set

struct	wrong_format_failure
	thrown, when reading data that is not in the supposed format More...

Typedefs
typedef std::pair< AlignerRestriction, infty_score_t >	task_t
	type of a task (used in computing k-best alignment)

typedef Matrix< double >	ProbMatrix
	matrix for storing probabilities More...

typedef SparseMatrix< double >	SparseProbMatrix
	sparse matrix for storing probabilities

typedef SparseMatrix< pf_score_t >	SparsePFScoreMatrix
	sparse matrix for storing partition functions

typedef AlignerRestriction	AlignerPRestriction
	restriction of AlignerP ( same as for Aligner )

typedef std::vector< EdgeEnd >	Alignment__edge_ends_t
	vector of alignment edge ends

typedef std::vector< ArcMatch >	ArcMatchVec
	Vector of arc matches.

typedef std::vector< ArcMatch::idx_type >	ArcMatchIdxVec
	Vector of arc match indices.

typedef size_t	size_type
	general size type

typedef size_type	pos_type
	type of a sequence position

typedef double	FLT_OR_DBL
	select FLT_OR_DBL More...

typedef std::vector< unsigned int >	intVec

typedef std::pair< unsigned int, unsigned int >	intPair

typedef std::pair< intPair, intPair >	intPPair

typedef const intPPair *	intPPairPTR

typedef std::vector< intPPair >::const_iterator	IntPPairCITER

typedef std::vector< double >	numseq_t

typedef long double	pf_t

typedef std::vector< infty_score_t >	ScoreVector
	matrix of scores supporting infinity

typedef std::vector< pf_score_t >	PFScoreVector
	Vector of partition functions.

typedef Matrix< infty_score_t >	ScoreMatrix
	matrix of scores supporting infinity

typedef Matrix< pf_score_t >	PFScoreMatrix
	Matrix of partition functions.

typedef long int	score_t
	type of the locarna score as defined by the class Scoring

typedef InftyInt	infty_score_t

typedef TaintedInftyInt	tainted_infty_score_t

typedef double	pf_score_t
	type of partition functions

Functions
std::ostream &	operator<< (std::ostream &out, AlignerRestriction r)

template<class T >
std::ostream &	operator<< (std::ostream &out, Alphabet< T > a)

bool	is_gap_symbol (char c)
	Test for gap symbol. More...

char	gap_symbol (Gap gap)
	simplified symbols of gaps

char	special_gap_symbol (Gap gap)
	special symbols of gaps

Gap	gap_code (char symbol)
	code of a gap symbol

void	transform_toupper (std::string &s)

void	normalize_rna_sequence (std::string &seq)
	Transform an RNA sequence string. More...

bool	has_prefix (const std::string &s, const std::string &p, size_t start=0)
	Test string prefix. More...

void	split_at_separator (const std::string &s, char sep, std::vector< std::string > &v)
	Tokenize string at separator symbol. More...

std::vector< std::string >	split_at_separator (const std::string &s, char sep)
	Tokenize string at separator symbol. More...

std::string	concat_with_separator (const std::vector< std::string > &v, char sep)
	Tokenize string at separator symbol. More...

bool	get_nonempty_line (std::istream &in, std::string &line)
	Get next non-empty/non-comment line. More...

double	sequence_identity (const string1 &seqA, const string1 &seqB)

double	prob_exp_f (int seqlen)
	expected probability of a base pair (null-model) More...

bool	frag_len_geq (size_t i, size_t j, size_t minlen)

size_t	frag_len (size_t i, size_t j)

bool	operator< (const BasePairs::LeftAdjEntry &e1, const BasePairs::LeftAdjEntry &e2)

bool	operator< (const BasePairs::RightAdjEntry &e1, const BasePairs::RightAdjEntry &e2)

std::ostream &	operator<< (std::ostream &out, const BasePairs::Arc &arc)

std::ostream &	operator<< (std::ostream &out, const PatternPairMap::patListTYPE &pat_pair_map)
	write pattern list of the PatternPairMap to stream More...

bool	operator< (const EPM &epm1, const EPM &epm2)

std::ostream &	operator<< (std::ostream &out, const EPM &epm)

template<class T1 >
T1	max3 (const T1 &first, const T1 &second, const T1 &third)

template<class T1 >
T1	max4 (const T1 &first, const T1 &second, const T1 &third, const T1 &fourth)

double	sqdiff (double x, double y)
	square difference

std::ostream &	operator<< (std::ostream &out, const TaintedInftyInt &x)

TaintedInftyInt	operator+ (const TaintedInftyInt &x, const FiniteInt &y)

TaintedInftyInt	operator- (const TaintedInftyInt &x, const FiniteInt &y)

TaintedInftyInt	operator+ (const InftyInt &x, const InftyInt &y)

TaintedInftyInt	operator- (const InftyInt &x, const InftyInt &y)

InftyInt	operator+ (const InftyInt &x, const FiniteInt &y)

InftyInt	operator- (const InftyInt &x, const FiniteInt &y)

FiniteInt	operator+ (const FiniteInt &x, const FiniteInt &y)

FiniteInt	operator- (const FiniteInt &x, const FiniteInt &y)

bool	operator== (const TaintedInftyInt &x, const TaintedInftyInt &y)

TaintedInftyInt	min (const TaintedInftyInt &x, const TaintedInftyInt &y)

TaintedInftyInt	max (const TaintedInftyInt &x, const TaintedInftyInt &y)

bool	operator> (const TaintedInftyInt &x, const TaintedInftyInt &y)

bool	operator< (const TaintedInftyInt &x, const TaintedInftyInt &y)

bool	operator>= (const TaintedInftyInt &x, const TaintedInftyInt &y)

bool	operator<= (const TaintedInftyInt &x, const TaintedInftyInt &y)

template<class T >
std::ostream &	operator<< (std::ostream &out, Matrix< T > mat)

template<class T >
std::istream &	operator>> (std::istream &in, Matrix< T > &mat)

std::ostream &	operator<< (std::ostream &out, const MultipleAlignment &ma)
	Write multiple alignment to stream. More...

bool	decode_argument (void *argument, int arg_type, const std::string &optarg)
	decode a string according to arg_type, for internal use More...

int	count_opts (option_def *options)

char *	sprint_option_name (char buf, option_def options, int i)

char *	sprint_option_xml (char buf, option_def options, int i)

char *	sprint_option_name_opt (char buf, option_def options, int i)

bool	process_options (int argc, char argv[], option_def options)
	process options More...

const char *	convert_arg_type (int arg_type)

void	print_options (option_def options[])

void	print_usage (char *progname, option_def options[])

void	print_galaxy_xml (char *progname, option_def options[])
	prints a galaxy wrapper in xml format More...

void	print_help (char *progname, option_def options[])

bool	process_options (int argc, char *argv[], option_def options[])

std::ostream &	operator<< (std::ostream &out, const Ribosum &ribosum)

bool	is_blank (std::string &s)

std::ostream &	operator<< (std::ostream &out, const RibosumFreq &ribosum)

std::string	read_pp_in_loop_block (const std::string &firstline, std::istream &in)

std::string	format_prob (double prob)
	output format for probabilities in pp files use limited precision; use scientific notation if it is shorter

template<class T >
std::ostream &	operator<< (std::ostream &out, const SparseMatrix< T > &m)
	Output operator. More...

template<class T >
std::ostream &	operator<< (std::ostream &out, const SparseVector< T > &v)
	Output operator. More...

std::ostream &	operator<< (std::ostream &out, const std::vector< SparsificationMapper::InfoForPosVec > &pos_vecs_)

std::ostream &	operator<< (std::ostream &out, const SparsificationMapper::InfoForPosVec &pos_vec_)

template<class T1 , class T2 >
std::ostream &	operator<< (std::ostream &out, const std::pair< T1, T2 > &pair)

template<class T >
std::ostream &	operator<< (std::ostream &out, const std::vector< T > &vec)

template<class T >
std::ostream &	operator<< (std::ostream &out, const type_wrapper< T > &x)

Variables
bool	trace_debugging_output =false
	a static switch to enable generating debugging logs

const std::string	the_gap_symbols = "-_~."

const std::string	simplified_gap_symbols = "---."

StopWatch	stopwatch
	global StopWatch object

char	O_error_msg_buffer [MYBUFSIZ]
	string buffer for error message

char *	O_error_msg =O_error_msg_buffer
	pointer to string buffer for error message

char	buf [MYBUFSIZ]
	buffer used for constructing small strings

std::vector< double >	punA_tab

std::vector< double >	punB_tab

Detailed Description

auxilliary types and global constants for use in locarna

Typedef Documentation

typedef double LocARNA::FLT_OR_DBL

select FLT_OR_DBL

Note: By defining as double, we rely on Vienna package compiled with LARGE_PF (defined in fold_vars.h); By defining this here, we get rid of dependency of header file ViennaRNA/fold_vars.h in pre-2.2.x version of the Vienna package. In 2.2.x, we simply redeclare the typedef.

typedef InftyInt LocARNA::infty_score_t

an extended score_t that can store and calculate with infinite values (i.p. we use -infty for invalid matrix entries)

typedef Matrix< double > LocARNA::ProbMatrix

matrix for storing probabilities

Matrix of probabilities.

Function Documentation

std::string LocARNA::concat_with_separator	(	const std::vector< std::string > &	v,
		char	sep
	)

Tokenize string at separator symbol.

Split at seperator symbol and write to output vector of strings.

Parameters

s	string
sep	separator
v[out]	vector of strings

int LocARNA::count_opts ( option_def * options )

Counts the options in (null-terminated) array

Parameters

options array of options

See also: process_options()

Returns: number of options in array

bool LocARNA::decode_argument	(	void *	argument,
		int	arg_type,
		const std::string &	optarg
	)

decode a string according to arg_type, for internal use

decode an argument according to specified type

Parameters

argument
arg_type
optarg

Returns: success

decode the string optarg according to the type of argument arg_type and write the result to argument

Returns: whether argument could be decoded

size_t LocARNA::frag_len	(	size_t	i,
		size_t	j
	)

inline

Number of bases in a fragment

Parameters

i	left end of fragment
j	right end of fragment

Returns: number of bases in range i..j

bool LocARNA::frag_len_geq	(	size_t	i,
		size_t	j,
		size_t	minlen
	)

inline

Test for sufficient fragment length

Parameters

i	left end of fragment
j	right end of fragment
minlen	minimum length of fragment

Returns: whether fragment has at least length minlen

bool LocARNA::get_nonempty_line	(	std::istream &	in,
		std::string &	line
	)

Get next non-empty/non-comment line.

Parameters

	in	input stream
[out]	line	line

Get the next line of stream in that is neither emtpy nor starts with white space (the latter is considered a comment in pp and (our variant of) clustalw files).

While newline is quoted concatenate lines. (note: this is kept simple, such that we cannot quote quotes)

Note: on failure, sets line to empty

Returns: success

bool LocARNA::has_prefix	(	const std::string &	s,
		const std::string &	p,
		size_t	start = `0`
	)

Test string prefix.

Parameters

s	string
p	prefix
start	optional start position

Returns: whether s has prefix p (after dropping the first start characters from s)

bool LocARNA::is_blank ( std::string & s )

Test for only blank characters

Parameters

s	string to be tested

Returns: whether s consists of only blank characters

bool LocARNA::is_gap_symbol ( char c )

Test for gap symbol.

Parameters

c	character to be tested

Returns: whether c codes for a gap according to global constant gap_symbols

TaintedInftyInt LocARNA::max	(	const TaintedInftyInt &	x,
		const TaintedInftyInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: max of x and y

template<class T1 >

T1 LocARNA::max3	(	const T1 &	first,
		const T1 &	second,
		const T1 &	third
	)

computes the maximum of three values

Parameters

first	first value
second	second value
third	third value

Returns: the maximum of the three input values

template<class T1 >

T1 LocARNA::max4	(	const T1 &	first,
		const T1 &	second,
		const T1 &	third,
		const T1 &	fourth
	)

computes the maximum of four values

Parameters

first	first value
second	second value
third	third value
fourth	value

Returns: the maximum of the four input values

TaintedInftyInt LocARNA::min	(	const TaintedInftyInt &	x,
		const TaintedInftyInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: min of x and y

void LocARNA::normalize_rna_sequence ( std::string & seq )

Transform an RNA sequence string.

Transform, such that all characters are upper case and Ts are translated to Us

Parameters

seq	sequence string

TaintedInftyInt LocARNA::operator+	(	const TaintedInftyInt &	x,
		const FiniteInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: x plus y

TaintedInftyInt LocARNA::operator+	(	const InftyInt &	x,
		const InftyInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: x plus y

InftyInt LocARNA::operator+	(	const InftyInt &	x,
		const FiniteInt &	y
	)

inline

Add

Parameters

x	operand 1
y	operand 2

Returns: x plus y

FiniteInt LocARNA::operator+	(	const FiniteInt &	x,
		const FiniteInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: x plus y

TaintedInftyInt LocARNA::operator-	(	const TaintedInftyInt &	x,
		const FiniteInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: x minus y

TaintedInftyInt LocARNA::operator-	(	const InftyInt &	x,
		const InftyInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: x minus y

InftyInt LocARNA::operator-	(	const InftyInt &	x,
		const FiniteInt &	y
	)

inline

Subtract

Parameters

x	operand 1
y	operand 2

Returns: x minus y

FiniteInt LocARNA::operator-	(	const FiniteInt &	x,
		const FiniteInt &	y
	)

inline

Parameters

x	operand 1
y	operand 2

Returns: x minus y

bool LocARNA::operator<	(	const BasePairs::LeftAdjEntry &	e1,
		const BasePairs::LeftAdjEntry &	e2
	)

compare right ends of arcs (for sorting)

bool LocARNA::operator<	(	const BasePairs::RightAdjEntry &	e1,
		const BasePairs::RightAdjEntry &	e2
	)

compare left ends of arcs (for sorting)

bool LocARNA::operator<	(	const TaintedInftyInt &	x,
		const TaintedInftyInt &	y
	)

inline

Less than operator

Parameters

x	operand 1
y	operand 2

Returns: whether x is less than y

Note: The result is undefined when comparing infinte values of the same sign.

bool LocARNA::operator<	(	const EPM &	epm1,
		const EPM &	epm2
	)

inline

compare EPMs (for sorting according to the tolerance left) epm1 input EPM epm2 input EPM

Returns: true, if the maximal tolerance that is left for epm1 is larger than the one for epm2 false, otherwise

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		const TaintedInftyInt &	x
	)

Output operator for writing object of TaintedInftyInt to output stream

Parameters

out	the output stream
x	the object to be written

Returns: output stream after writing x

template<class T >

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		Alphabet< T >	a
	)

Output operator writing alphabet to output stream

Parameters

out	the output stream
a	the alphabet

Returns: output stream after writing alphabet

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		AlignerRestriction	r
	)

inline

Output operator for objects of AlignerRestrictions

Parameters

out	output stream
r	object of AlignerRestriction to be written to stream

Returns: output stream

Note: Writes r to out

std::ostream & LocARNA::operator<<	(	std::ostream &	out,
		const std::vector< SparsificationMapper::InfoForPosVec > &	pos_vecs_
	)

prints all valid sequence positions with additional information for all indices

Parameters

out	output stream object
pos_vecs_	input vector

Returns: output stream object

std::ostream & LocARNA::operator<<	(	std::ostream &	out,
		const SparsificationMapper::InfoForPosVec &	pos_vec_
	)

prints all valid sequence positions with additional information for one index

Parameters

out	output stream object
pos_vec_	input vector

Returns: output stream object

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		const Ribosum &	ribosum
	)

Output operator

Parameters

out	output stream
ribosum	Ribosum to be written to stream

Returns: output stream after writing

std::ostream & LocARNA::operator<<	(	std::ostream &	out,
		const BasePairs::Arc &	arc
	)

Output operator for writing arc to output stream

Parameters

out	the output stream
arc	the arc to be written

Returns: output stream after writing arc

template<class T >

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		Matrix< T >	mat
	)

Output operator for writing (templated) matrix to output stream

Parameters

out	the output stream
mat	the matrix to be written

Returns: output stream after writing matrix mat

template<class T >

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		const SparseVector< T > &	v
	)

inline

Output operator.

Parameters

out	output stream
m	sparse vector to be writing to stream

Returns: output stream after writing

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		const RibosumFreq &	ribosum
	)

Output operator

Parameters

out	output stream
ribosum	Ribosum to be written to stream

Returns: output stream after writing

template<class T >

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		const SparseMatrix< T > &	m
	)

inline

Output operator.

Parameters

out	output stream
m	sparse matrix to be writing to stream

Returns: output stream after writing

template<class T >

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		const std::vector< T > &	vec
	)

prints a vector

Parameters

out	output stream object
vec	vector

Returns: output stream object

std::ostream& LocARNA::operator<<	(	std::ostream &	out,
		const EPM &	epm
	)

inline

prints the EPM

Parameters

out	output stream object
epm	EPM that is printed

Returns: output stream object

std::ostream & LocARNA::operator<<	(	std::ostream &	out,
		const MultipleAlignment &	ma
	)

Write multiple alignment to stream.

Parameters

out	output stream
ma	multiple alignment

Returns: output stream

std::ostream & LocARNA::operator<<	(	std::ostream &	out,
		const PatternPairMap::patListTYPE &	pat_pair_map
	)

write pattern list of the PatternPairMap to stream

Parameters

out	output stream object
the	pattern list of the PatternPairMap

Returns: output stream object

bool LocARNA::operator<=	(	const TaintedInftyInt &	x,
		const TaintedInftyInt &	y
	)

inline

Less or equal than operator

Parameters

x	operand 1
y	operand 2

Returns: whether x is less or equal than y

Note: The result is undefined when comparing infinte values of the same sign.

bool LocARNA::operator==	(	const TaintedInftyInt &	x,
		const TaintedInftyInt &	y
	)

inline

Parameters

x	operand 1 (tainted)
y	operand 2 (tainted)

Returns: whether x equals y

bool LocARNA::operator>	(	const TaintedInftyInt &	x,
		const TaintedInftyInt &	y
	)

inline

Greater than operator

Parameters

x	operand 1
y	operand 2

Returns: whether x is greater than y

Note: The result is undefined when comparing infinte values of the same sign.

bool LocARNA::operator>=	(	const TaintedInftyInt &	x,
		const TaintedInftyInt &	y
	)

inline

Greater or equal than operator

Parameters

x	operand 1
y	operand 2

Returns: whether x is greater or equal than y

Note: The result is undefined when comparing infinte values of the same sign.

template<class T >

std::istream& LocARNA::operator>>	(	std::istream &	in,
		Matrix< T > &	mat
	)

Input operator for reading (templated) matrix from input stream

Parameters

	in	the input stream
[out]	mat	the matrix to be read

Returns: input stream after reading matrix mat

void LocARNA::print_galaxy_xml	(	char *	progname,
		option_def	options[]
	)

prints a galaxy wrapper in xml format

Parameters

progname	Name of program
options	Options array

void LocARNA::print_help	(	char *	progname,
		option_def	options[]
	)

prints a standard help string suited for short help output

Parameters

progname	Name of program
options	Options array

void LocARNA::print_options ( option_def options[] )

Print all options and their settings to standard out

Parameters

options options array

void LocARNA::print_usage	(	char *	progname,
		option_def	options[]
	)

prints a standard usage string suited for short help output

Parameters

progname	Name of program
options	Options array

double LocARNA::prob_exp_f ( int seqlen )

inline

expected probability of a base pair (null-model)

Note: magic formula for expected probability (aka background); actually questionable

bool LocARNA::process_options	(	int	argc,
		char *	argv[],
		option_def	options[]
	)

process options

bool LocARNA::process_options	(	int	argc,
		char *	argv[],
		option_def *	options
	)

process options

Processes an argument string as given to main() according to an array of options descriptions of type option_def.

Parameters

argc	argument counter from main()
argv	argument vector from main()
options	array describing the options

Returns: TRUE if all required options are read FALSE if a required option is missing, or unknown options occured

Note: last entry in definitions array should contain only 0's (in fact longname==0 and shortname==0 is tested)

void LocARNA::split_at_separator	(	const std::string &	s,
		char	sep,
		std::vector< std::string > &	v
	)

Tokenize string at separator symbol.

Split at seperator symbol and write to output vector of strings. Output vector is overwritten.

Parameters

s	string
sep	separator
v[out]	vector of strings

std::vector< std::string > LocARNA::split_at_separator	(	const std::string &	s,
		char	sep
	)

Tokenize string at separator symbol.

Split at seperator symbol and write to output vector of strings. Output vector is overwritten.

Parameters

s	string
sep	separator

Returns: vector of strings

char * LocARNA::sprint_option_name	(	char *	buf,
		option_def *	options,
		int	i
	)

Print option name to string buffer

Parameters

buf	String buffer
options	options array
i	index of option to be printed

Returns: pointer to string buffer

char * LocARNA::sprint_option_name_opt	(	char *	buf,
		option_def *	options,
		int	i
	)

Print option name to string buffer, marking whether it is optional by []

Parameters

buf	String buffer
options	options array
i	index of option to be printed

Returns: pointer to string buffer

char * LocARNA::sprint_option_xml	(	char *	buf,
		option_def *	options,
		int	i
	)

Print an option as xml in Galaxy Wrapper format to string buffer

Parameters

buf	String buffer
options	options array
i	index of option to be printed

Returns: pointer to string buffer

void LocARNA::transform_toupper ( std::string & s )

Convert string to all upper case

Parameters

[in,out] s string

Postcondition: string is all upper case

Variable Documentation

std::vector<double> LocARNA::punA_tab

vector for unpaired probabilities temporarily required by sigma_

Note: initialized in precompute sigma, if needed

std::vector<double> LocARNA::punB_tab

vector for unpaired probabilities

See also: punB_tab

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

Function Documentation

Variable Documentation