FD Namespace Reference

Classes
class	Array
class	BaseException
class	GenericCastException
class	GeneralException
class	ExceptionStack
class	BinaryAND
class	BinaryOR
class	Buffer
class	BufferException
class	OutputCacheInfo
class	InputCacheInfo
class	BufferedNode
class	Collector
class	CompileObject
class	Complex
class	CompositeType
class	Constant
class	DoubleDispatchException
class	DoubleDispatch
class	NodeNotFoundException
class	NoSinkNodeException
class	NoInputNodeException
class	FactoryNotFoundException
class	ExceptionObject
class	AppFactory
class	_AppFactory
class	ExternalApp
class	FlowPref
class	FlowException
union	FloatManip
class	IExtensions
class	IntfNode
class	InputTranslator
class	Iterator
class	BaseMatrix
class	Matrix
struct	MatrixMethod
class	DynVec_
class	GenericType
class	PrintableGenericType
class	NetCType
class	FILEPTR
class	FILEDES
class	String
class	Network
class	NodeInput
class	Node
class	NotInitializedException
class	NodeException
class	_NodeFactory
class	NodeFactory
class	Object
class	_ObjectFactory
class	ObjectFactory
class	NilObject
class	ObjectParam
class	ParsingException
class	ObjectPool
class	CastException
class	Pack
class	ParameterSet
class	ParameterException
class	Power
class	PtrCastException
class	PtrException
class	RCPtr
struct	compare_const_type_info_ptr
class	TypeMap
class	Conversion
class	dummy_conv_table_init_class
class	RTCUser
class	RTCTimer
class	network_socket
class	socket_streambuf
class	socket_ostream
class	socket_istream
class	socket_iostream
class	Stream
class	IStream
class	OStream
class	IOStream
class	EOFObject
class	fileptr_streambuf
class	fileptr_ostream
class	fileptr_istream
class	fileptr_iostream
class	fd_streambuf
class	fd_ostream
class	fd_istream
class	fd_iostream
class	pipe_streambuf
class	pipe_istream
class	pipe_iostream
class	ThreadedIterator
class	TTraits
struct	TypeTraits
struct	TypeTraits< RCPtr< T > >
struct	TypeTraits< T * >
class	DocParameterDataText
class	UIDocument
class	GUILinkPoint
class	UILink
class	UINetTerminal
class	UINetwork
class	UINode
class	ParameterText
class	UINodeParameters
class	ItemInfo
class	NodeInfo
class	UINodeRepository
class	UINote
class	UITerminal
class	UnPack
class	URLHandler
class	Variable
class	BaseVector
class	Vector
struct	VecMethod
class	VectorPool
class	SymbolSet
class	VirtualMethods
class	OFWrapper
class	_FFTWrap
class	allpass
class	comb
class	revmodel
class	FuzzyFunction
class	FuzzyModel
class	FuzzyRule
class	FuzzySet
class	GenericModel
class	InferenceModel
class	TrapezoidalFunction
class	TriangularFunction
class	AcousticModel
class	Tag
class	AudioInfo
class	Covariance
class	DiagonalCovariance
class	CovarianceSet
class	DiagGMM
class	Gaussian
class	GaussianSet
class	Score
class	GMM
class	GMMSet
class	GMMScore
class	Mean
class	MeanSet
class	Model
class	Transition
class	State
class	ViterbiNode
class	FFLayer
class	FFNet
class	NNetSet
class	TrainingAlgo
class	TrainingDeltaBarDelta
class	TrainingSCG
class	TrainingQProp
class	TrainingWeightDeltaBarDelta
class	GRunContext
class	GtkPlotProbe
class	DocParameterData
class	GUIDocument
class	GUILink
class	GUINetPopup
class	NodeLabel
class	NodeLabel_class
class	GUINetTerminal
class	GUINetwork
class	GUINode
class	ParameterData
class	GUINodeParameters
class	GUINodeTooltip
class	GUINote
class	GUITerminal
class	KeyPad
class	MultiPlotProbe
class	PlotProbe
class	Probe
class	TextProbe
class	vflowGUI
class	VFlowPrefDialog
class	MutualInformation
class	Cell
class	CodebookMap
class	FeatureMap
class	KMeans
class	MMIScore
class	MSVQ
class	RBF
class	VQ
struct	MatrixMethod< T, TTraits::Object >
struct	MatrixMethod< T, TTraits::ObjectPointer >
struct	MatrixMethod< T, TTraits::Basic >
struct	MatrixMethod< T, TTraits::Unknown >
struct	TypeTraits< std::complex< T > >
struct	VecMethod< T, TTraits::Object >
struct	VecMethod< T, TTraits::ObjectPointer >
struct	VecMethod< T, TTraits::Basic >
struct	VecMethod< T, TTraits::Unknown >
Typedefs
typedef NetCType< char >	Char
	Char which is a NetCType<char>.
typedef NetCType< int >	Int
	Int which is a NetCType<int>.
typedef NetCType< float >	Float
	Float which is a NetCType<float>.
typedef NetCType< double >	Double
	Double which is a NetCType<double>.
typedef NetCType< bool >	Bool
	Bool which is a NetCType<double>.
typedef std::map< std::string, Node * >::value_type	nodeEntry
typedef std::map< std::string, _NodeFactory * >::value_type	factoryEntry
typedef RCPtr< Object >	ObjectRef
typedef ObjectRef(*	conv_func )(ObjectRef)
typedef ObjectRef(*	url_func )(const std::string &url, int flags)
Functions
template<class T>
std::istream &	operator>> (std::istream &in, Complex< T > &value)
int	version_check (const char *vers, const char *abi_vers, const char *unused_vers=NULL)
void	build_flog_table ()
float	flog (float f)
void	fflogv (const float *fin, float *fout, int len)
void	build_fexp_table ()
float	fexp (float f)
void	prefetchnta (void *ptr)
void	prefetcht0 (void *ptr)
void	prefetcht1 (void *ptr)
void	prefetcht2 (void *ptr)
void	emms ()
template<class T>
T &	max (T &a, T &b)
int	max (int a, int b)
float	max (float a, float b)
double	max (double a, double b)
template<class T>
T &	min (T &a, T &b)
int	min (int a, int b)
float	min (float a, float b)
double	min (double a, double b)
template<class T>
T	sqr (T x)
template<class T>
T	abs (T x)
template<int M2>
int	_log2 (int i)
template<>
int	_log2< 1 > (int i)
int	log2 (int i)
float	gauss_rand (float sd)
std::istream &	operator>> (std::istream &in, String &str)
	operator >> for String
template<class T>
std::string	ObjectGetClassName ()
bool	isValidType (std::istream &in, std::string expectedType, bool binary=false)
template<class T>
std::ostream &	operator<< (std::ostream &out, const RCPtr< T > &ref)
template<class T>
std::ostream &	operator<< (std::ostream &out, const std::vector< T > &v)
template<class T>
std::ostream &	operator<< (std::ostream &out, const std::vector< T * > &v)
template<class T>
std::istream &	operator>> (std::istream &in, std::vector< T > &v)
template<class T>
std::istream &	operator>> (std::istream &in, std::vector< T * > &v)
template<class T>
std::istream &	operator>> (std::istream &in, RCPtr< T > &o)
template<class T>
std::istream &	operator>> (std::istream &in, T *&o)
template<class T>
T	object_ptr_cast (const ObjectRef &ref)
template<class T>
T &	object_cast (const ObjectRef &ref)
template<class T>
T &	dereference_cast (const ObjectRef &ref)
template<class T>
bool &	object_kind_of (const ObjectRef &ref)
template<class T>
bool &	object_has_type (const ObjectRef &ref)
	DEFINE_DOUBLE_VTABLE (addVtable)
ObjectRef	operator+ (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (subVtable)
ObjectRef	operator- (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (mulVtable)
ObjectRef	operator * (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (divVtable)
ObjectRef	operator/ (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (smallerVtable)
ObjectRef	operator< (ObjectRef x, ObjectRef y)
ObjectRef	operator> (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (equalVtable)
ObjectRef	operator== (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (maxVtable)
ObjectRef	max (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (minVtable)
ObjectRef	min (ObjectRef x, ObjectRef y)
	DEFINE_DOUBLE_VTABLE (concatVtable)
ObjectRef	concat (ObjectRef x, ObjectRef y)
std::vector< std::string >	envList (char *envName, bool include_home=true)
void	scanDL (bool debug=false)
void *	workloop (void *param)
template<class T>
void	vec_copy (const T *x, T *y, int len)
template<class T>
T	vec_inner_prod (const T *a, const T *b, int len)
template<class T>
void	vec_add_vec (const T *a, const T *b, T *c, int len)
template<class T>
void	vec_sub_vec (const T *a, const T *b, T *c, int len)
template<class T>
void	vec_mul_vec (const T *a, const T *b, T *c, int len)
template<class T>
void	vec_mul_and_add (const T *a, const T *b, T *c, int len)
template<class T>
void	vec_mul_and_add (const T a, const T *b, T *c, int len)
template<class T>
void	vec_div_vec (const T *a, const T *b, T *c, int len)
template<class T>
void	vec_add_scal (const T a, const T *b, T *c, int len)
template<class T>
void	vec_mul_scal (const T a, const T *b, T *c, int len)
template<class T>
T	vec_dist2 (const T *a, const T *b, int len)
template<class T>
T	vec_mahalanobis2 (const T *a, const T *b, const T *c, int len)
template<class T>
T	vec_sum (const T *a, int len)
template<class T>
T	vec_norm2 (const T *a, int len)
template<class T>
void	vec_inv (const T *a, T *b, int len)
template<class T>
void	vec_sqrt (const T *a, T *b, int len)
template<class T>
void	vec_corr_cont (const T *a, T *filt, T *out, int len, int filtLen)
template<class T>
void	vec_conv_cont (const T *a, T *filt, T *out, int len, int filtLen)
float	vec_inner_prod_float (const float *a, const float *b, int len)
template<>
float	vec_inner_prod< float > (const float *a, const float *b, int len)
float	vec_inner_prod_3dnow (const float *a, const float *b, int len) ERROR_3DNOW_NI inline void vec_add_vec_3dnow(const float *a
float const float float int len ERROR_3DNOW_NI void	vec_sub_vec_3dnow (const float *a, const float *b, float *c, int len) ERROR_3DNOW_NI inline void vec_mul_vec_3dnow(const float *a
float const float float int len ERROR_3DNOW_NI void const float float int len ERROR_3DNOW_NI void	vec_add_scal_3dnow (const float a, const float *b, float *c, int len) ERROR_3DNOW_NI inline void vec_mul_scal_3dnow(const float a
float const float float int len ERROR_3DNOW_NI void const float float int len ERROR_3DNOW_NI void const float float int len ERROR_3DNOW_NI float	vec_dist_3dnow (const float *a, const float *b, int len) ERROR_3DNOW_NI inline float vec_mahalanobis_3dnow(const float *a
float const float float int len ERROR_3DNOW_NI void const float float int len ERROR_3DNOW_NI void const float float int len ERROR_3DNOW_NI float const float const float int len ERROR_3DNOW_NI float	vec_sum_3dnow (const float *a, int len) ERROR_3DNOW_NI inline float vec_norm2_3dnow(const float *a
float const float float int len ERROR_3DNOW_NI void const float float int len ERROR_3DNOW_NI void const float float int len ERROR_3DNOW_NI float const float const float int len ERROR_3DNOW_NI float int len ERROR_3DNOW_NI void	vec_inv_3dnow (const float *a, float *b, int len) ERROR_3DNOW_NI inline void vec_sqrt_3dnow(const float *a
float	vec_inner_prod_sse (const float *a, const float *b, int len) ERROR_SSE_NI inline float vec_mahalanobis2_mul4_sse(const float *a
template<class T>
void	_vector_printOn (const Vector< T > &v, std::ostream &out)
template<>
void	_vector_printOn (const Vector< std::string > &v, std::ostream &out)
template<class T>
void	_vector_printOn (const Vector< T * > &v, std::ostream &out)
template<class T>
void	_vector_readFrom (Vector< T > &v, std::istream &in)
template<>
void	_vector_readFrom (Vector< std::string > &v, std::istream &in)
template<class T>
void	_vector_readFrom (Vector< T * > &v, std::istream &in)
bool	isValidVectorType (std::istream &in, std::string type, const std::string &className)
template<class T>
std::istream &	operator>> (std::istream &in, Vector< T > &vec)
template<class T>
Vector< T > &	operator+= (Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T > &	operator-= (Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T > &	operator *= (Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T > &	operator/= (Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T >	operator+ (const Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T >	operator- (const Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T >	operator * (const Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T >	operator/ (const Vector< T > &v1, const Vector< T > &v2)
template<class T>
Vector< T >	operator- (Vector< T > &v1)
template<class T>
Vector< T > &	operator+= (Vector< T > &v1, T scal)
template<class T>
Vector< T > &	operator-= (Vector< T > &v1, T scal)
template<class T>
Vector< T > &	operator *= (Vector< T > &v1, T scal)
template<class T>
Vector< T > &	operator/= (Vector< T > &v1, T scal)
template<class T>
Vector< T >	operator+ (const Vector< T > &v1, T scal)
template<class T>
Vector< T >	operator- (const Vector< T > &v1, T scal)
template<class T>
Vector< T >	operator * (const Vector< T > &v1, T scal)
template<class T>
Vector< T >	operator/ (const Vector< T > &v1, T scal)
VirtualMethods *	vmethod ()
void	string_to_token (Vector< std::string > &outputVector, const std::string &inputString, Vector< char > &keepToken, Vector< char > &discardToken)
bool	string_contain_nl_sys_command (Vector< std::string > &outputVector, std::string &inputString)
std::string	vector_of_string_to_string (Vector< std::string >::iterator &startOfStringIt, Vector< std::string > &inputVector, std::string stringSeparator=" ")
std::string	int_to_string (int inputInteger)
Covariance *	NewDiagonalCovariance (int dim)
std::istream &	operator>> (std::istream &in, DiagonalCovariance &cov)
std::istream &	operator>> (std::istream &in, DiagGMM &gmm)
std::istream &	operator>> (std::istream &in, Gaussian &gauss)
std::istream &	operator>> (std::istream &in, GMM &gmm)
std::istream &	operator>> (std::istream &in, FFLayer &layer)
std::istream &	operator>> (std::istream &in, FFNet &net)
void	sigmoid (float *x, float *y, int len)
void	deriv_sigmoid (float *x, float *y, int len)
void	tansig (float *x, float *y, int len)
void	deriv_tansig (float *x, float *y, int len)
void	lin (float *x, float *y, int len)
void	deriv_lin (float *x, float *y, int len)
std::ostream &	operator<< (std::ostream &out, const NNetSet &cell)
GtkType	NodeLabel_get_type ()
GtkWidget *	node_item_new (gchar *label, UINetwork *net)
std::string	ask_string_dialog (const char *question, const char *default_str)
gint	close_save_dialog (const char *question)
double	entropy_funct (double x)
std::ostream &	operator<< (std::ostream &out, const Cell &cell)
std::ostream &	operator<< (std::ostream &out, const CodebookMap &cell)
std::ostream &	operator<< (std::ostream &out, const FeatureMap &cell)
Variables
float	logtable2 [FLOGLOOKUP2SIZE]
float	exptable [FEXPSIZE]
ObjectRef	TrueObject
	TrueObject = NetCType<Bool>(true).
ObjectRef	FalseObject
	FalseObject = NetCType<Bool>(false).
ObjectRef	nilObject
float const float *	b
float const float float *	c
VectorPool< float >	floatVectorPool
VectorPool< double >	doubleVectorPool
_FFTWrap	FFTWrap
const int	numcombs = 8
const int	numallpasses = 4
const float	muted = 0
const float	fixedgain = 0.015f
const float	scalewet = 3
const float	scaledry = 2
const float	scaledamp = 0.4f
const float	scaleroom = 0.28f
const float	offsetroom = 0.7f
const float	initialroom = 0.5f
const float	initialdamp = 0.5f
const float	initialwet = 1/scalewet
const float	initialdry = 0
const float	initialwidth = 1
const float	initialmode = 0
const float	freezemode = 0.5f
const int	stereospread = 23
const int	combtuningL1 = 1116
const int	combtuningR1 = 1116+stereospread
const int	combtuningL2 = 1188
const int	combtuningR2 = 1188+stereospread
const int	combtuningL3 = 1277
const int	combtuningR3 = 1277+stereospread
const int	combtuningL4 = 1356
const int	combtuningR4 = 1356+stereospread
const int	combtuningL5 = 1422
const int	combtuningR5 = 1422+stereospread
const int	combtuningL6 = 1491
const int	combtuningR6 = 1491+stereospread
const int	combtuningL7 = 1557
const int	combtuningR7 = 1557+stereospread
const int	combtuningL8 = 1617
const int	combtuningR8 = 1617+stereospread
const int	allpasstuningL1 = 556
const int	allpasstuningR1 = 556+stereospread
const int	allpasstuningL2 = 441
const int	allpasstuningR2 = 441+stereospread
const int	allpasstuningL3 = 341
const int	allpasstuningR3 = 341+stereospread
const int	allpasstuningL4 = 225
const int	allpasstuningR4 = 225+stereospread
FD::ViterbiNode	numberStates
int	numberFrames
vector< State * >	states
vector< Vector< float > * >	frames

---

Detailed Description

The ThreadedIterator class is intended to compute at a defined Rate per second (RPS) its output. It is useful for async computing.

Author:

Dominic Letourneau, Jonathan Audet

---

Typedef Documentation

typedef std::map<std::string, Node*>::value_type FD::nodeEntry

Definition of the type we need for the dictionaries

typedef RCPtr<Object> FD::ObjectRef

Smart pointer to Object called ObjectRef Author: Jean-Marc Valin Version: 1.0

---

Function Documentation

template<class T> T FD::abs (  T  x  )  [inline]

Absolute value function

template<class T> T& FD::dereference_cast (  const ObjectRef &  ref  )  [inline]

The type cast from ObjectRef

float FD::gauss_rand (  float  sd  )  [inline]

Gaussian random generator

std::string FD::int_to_string (  int  inputInteger  )

Global function. This function is used to transform an integer into a string. Parameters: inputInteger  The integer to transform into a string. Returns: a string. Author: Luc Lussier

template<class T> T& FD::max (  T &  a, T &  b )

Max function

template<class T> T& FD::min (  T &  a, T &  b )

Min function

Covariance* FD::NewDiagonalCovariance (  int  dim  )  [inline]

Function that acts as a factory for diagonal covariance

template<class T> T& FD::object_cast (  const ObjectRef &  ref  )  [inline]

This is the default (and slowest) implementation

template<class T> bool& FD::object_has_type (  const ObjectRef &  ref  )  [inline]

Is the object of type T (exact match)

template<class T> bool& FD::object_kind_of (  const ObjectRef &  ref  )  [inline]

Does the object derive from T

template<class T> T FD::object_ptr_cast (  const ObjectRef &  ref  )  [inline]

The object pointer cast from ObjectRef

std::istream& FD::operator>> (  std::istream &  in, FFLayer &  layer )

Extraction operator for FFLayer

std::istream& FD::operator>> (  std::istream &  in, GMM &  gmm )

extractor for GMM

std::istream& FD::operator>> (  std::istream &  in, DiagGMM &  gmm )

extractor for DiagGMM

std::istream& FD::operator>> (  std::istream &  in, DiagonalCovariance &  cov )

extractor operator

template<class T> std::istream& FD::operator>> (  std::istream &  in, Complex< T > &  value )

operator >> for Complex<T> Parameters: in  input stream value  the Complex<T> value to print Returns: istream the input stream

template<class T> T FD::sqr (  T  x  )  [inline]

Square function

bool FD::string_contain_nl_sys_command (  Vector< std::string > &  outputVector, std::string &  inputString )

Global function. This function look for a "nl_sys_command" token at the first position of the string to determine if the string contain a command. Commands are used by the various modules to communicate between each others. Each module define it's own commands which can contain an arbitrary number of parameters. Parameters: outputVector  A vector<string> to which string tokens are added. inputString  A string that will be cut into tokens. Returns: True if the string contain a command and False if no command is found inside the string. Author: Luc Lussier

void FD::string_to_token (  Vector< std::string > &  outputVector, const std::string &  inputString, Vector< char > &  keepToken, Vector< char > &  discardToken )

Global function. Transform a string type string to a vector of string token. Each token is separated either by white space or by specified discardToken. Special keepToken can also be specified individually. See the test file for a demonstration of the behavior. Parameters: outputVector  A vector<string> to which the tokens are added inputString  A string that will be cut into tokens keepToken  A vector of character that specify some character that should be made into a single character token discardToken  A vector of character that are to be used like white spaces to break tokens Author: Luc Lussier

std::string FD::vector_of_string_to_string (  Vector< std::string >::iterator &  startOfStringIt, Vector< std::string > &  inputVector, std::string  stringSeparator = " " )

Global function. This function is used to transform a vector<string> back into a string. The vector token are separated by the specified string separator or by default by a white space. Parameters: startOfStringIt  Iterator pointing to the first element to add to the string. inputVector  A vector<string> that will be transformed back into a string. cSeparator  Default parameter. The string added between the string token as a separator while forming the new string. The default is " ". Returns: A string formed from the inputVector Author: Luc Lussier

---