<head>
<title>Edinburgh Speech Tools Index</title>
</head>
<body background="http://www.cstr.ed.ac.uk/images/cstr_background.jpg"
bgcolor="#ffffff" link="#0000ff"
vlink="#dd0000" text="#000088" alink="9000ff">
<A HREF = "http://www.cstr.ed.ac.uk/">
<IMG align=left BORDER=0 SRC = "cstr.gif"></A>
<A HREF="http://www.cstr.ed.ac.uk/projects/speech_tools.html">
<IMG BORDER=0 ALIGN=right SRC="est.jpg" width=150 height=93></A>
<br>
<h1>
Edinburgh Speech Tools<br>
<small><small><b>V1.1.0 August 1998</b></small></small>
</h1>
<br clear=left>
<pre>
</pre>
<H1>Table of Contents</H1>
<H2>General stuff</H2>
<UL>
<LI><A HREF="-theunderlyingHVorFWaccumulatorsaresharedvia.html">- the underlying HV or FW accumulators are shared via</A>
<LI><A HREF="Axiliaryoperationsonutterancestructures..html">Axiliary operations on utterance structures.</A>
<LI><A HREF="ChannelTypes.html">Channel Types</A>
<UL><LI><A HREF="ChannelTypeNumberringScheme.html">Channel Type Numberring Scheme</A>
</UL><LI><A HREF="DeltaandAccelerationcoefficents.html">Delta and Acceleration coefficents</A>
<LI><A HREF="EST_FeatureSample.html#Information functions ">EST_FeatureSample::Information functions </A>
<LI><A HREF="EST_Features.html#Access functions which return EST_Val. ">EST_Features::Access functions which return EST_Val. </A>
<LI><A HREF="EST_Features.html#Access functions which return types. ">EST_Features::Access functions which return types. </A>
<LI><A HREF="EST_Features.html#File I/O">EST_Features::File I/O</A>
<LI><A HREF="EST_Features.html#Iteration">EST_Features::Iteration</A>
<LI><A HREF="EST_Features.html#Setting features">EST_Features::Setting features</A>
<LI><A HREF="EST_Features.html#Utility functions">EST_Features::Utility functions</A>
<LI><A HREF="EST_Item.html#Constructor Functions ">EST_Item::Constructor Functions </A>
<LI><A HREF="EST_Item.html#Cross relational access ">EST_Item::Cross relational access </A>
<LI><A HREF="EST_Item.html#Feature access functions. ">EST_Item::Feature access functions. </A>
<LI><A HREF="EST_Item.html#Feature setting functions.">EST_Item::Feature setting functions.</A>
<LI><A HREF="EST_Item.html#Utility feature functions">EST_Item::Utility feature functions</A>
<LI><A HREF="EST_Item_Content.html#Constructor Functions ">EST_Item_Content::Constructor Functions </A>
<LI><A HREF="EST_Item_Content.html#Relation related member functions ">EST_Item_Content::Relation related member functions </A>
<LI><A HREF="EST_Regex.html#Assignment ">EST_Regex::Assignment </A>
<LI><A HREF="EST_SCFG.html#Constructor and initialisation functions ">EST_SCFG::Constructor and initialisation functions </A>
<LI><A HREF="EST_SCFG.html#file i/o functions ">EST_SCFG::file i/o functions </A>
<LI><A HREF="EST_SCFG.html#utility functions ">EST_SCFG::utility functions </A>
<LI><A HREF="EST_SCFG_Chart.html#Constructor and initialisation functions ">EST_SCFG_Chart::Constructor and initialisation functions </A>
<LI><A HREF="EST_SCFG_Chart.html#Grammar and parse string initialisation functions ">EST_SCFG_Chart::Grammar and parse string initialisation functions </A>
<LI><A HREF="EST_SCFG_Chart.html#parsing functions ">EST_SCFG_Chart::parsing functions </A>
<LI><A HREF="EST_SCFG_Chart_Edge.html#Constructor and initialisation functions ">EST_SCFG_Chart_Edge::Constructor and initialisation functions </A>
<LI><A HREF="EST_Server.html#Client end constructors.">EST_Server::Client end constructors.</A>
<LI><A HREF="EST_Server.html#Server end constructors">EST_Server::Server end constructors</A>
<LI><A HREF="EST_Server.html#connection management">EST_Server::connection management</A>
<LI><A HREF="EST_Server.html#information about the server.">EST_Server::information about the server.</A>
<LI><A HREF="EST_ServiceTable.html#Finding What Services Are Available.">EST_ServiceTable::Finding What Services Are Available.</A>
<LI><A HREF="EST_String.html#After ">EST_String::After </A>
<LI><A HREF="EST_String.html#At ">EST_String::At </A>
<LI><A HREF="EST_String.html#Before ">EST_String::Before </A>
<LI><A HREF="EST_String.html#Chop out part of string ">EST_String::Chop out part of string </A>
<LI><A HREF="EST_String.html#Does string contain something? ">EST_String::Does string contain something? </A>
<LI><A HREF="EST_String.html#Does string exactly match? ">EST_String::Does string exactly match? </A>
<LI><A HREF="EST_String.html#Extract Substrings ">EST_String::Extract Substrings </A>
<LI><A HREF="EST_String.html#Finding substrings ">EST_String::Finding substrings </A>
<LI><A HREF="EST_String.html#Frequency counts ">EST_String::Frequency counts </A>
<LI><A HREF="EST_String.html#Get position of something ">EST_String::Get position of something </A>
<LI><A HREF="EST_String.html#Global replacement ">EST_String::Global replacement </A>
<LI><A HREF="EST_String.html#Global search and replace ">EST_String::Global search and replace </A>
<LI><A HREF="EST_String.html#Operators ">EST_String::Operators </A>
<UL><LI><A HREF="EST_String.html#Add to end of string. ">Add to end of string. </A>
<LI><A HREF="EST_String.html#Asignment ">Asignment </A>
<LI><A HREF="EST_String.html#Concatenation ">Concatenation </A>
<LI><A HREF="EST_String.html#relational operators ">relational operators </A>
</UL><LI><A HREF="EST_String.html#Quoting ">EST_String::Quoting </A>
<LI><A HREF="EST_String.html#Search for something ">EST_String::Search for something </A>
<LI><A HREF="EST_String.html#Split a string into parts.">EST_String::Split a string into parts.</A>
<LI><A HREF="EST_String.html#String comparison.">EST_String::String comparison.</A>
<LI><A HREF="EST_TBuffer.h.html">EST_TBuffer.h</A>
<UL><LI><A HREF="EST_TBuffer.html#Access to the memory itself. ">EST_TBuffer.h::EST_TBuffer::Access to the memory itself. </A>
<LI><A HREF="EST_TBuffer.html#Methods to make sure there is enough space. ">EST_TBuffer.h::EST_TBuffer::Methods to make sure there is enough space. </A>
</UL><LI><A HREF="EST_TDeque.html#inverse stack">EST_TDeque::inverse stack</A>
<LI><A HREF="EST_TDeque.html#perl">EST_TDeque::perl</A>
<LI><A HREF="EST_TDeque.html#queue">EST_TDeque::queue</A>
<LI><A HREF="EST_TDeque.html#stack">EST_TDeque::stack</A>
<LI><A HREF="EST_TIterator.html#Access">EST_TIterator::Access</A>
<LI><A HREF="EST_TIterator.html#End Tests">EST_TIterator::End Tests</A>
<LI><A HREF="EST_TIterator.html#Moving Forward">EST_TIterator::Moving Forward</A>
<LI><A HREF="EST_TKVL.html#Access functions.">EST_TKVL::Access functions.</A>
<LI><A HREF="EST_TKVL.html#Constructor functions ">EST_TKVL::Constructor functions </A>
<LI><A HREF="EST_TList.html#Access functions for reading and writing items.">EST_TList::Access functions for reading and writing items.</A>
<LI><A HREF="EST_TList.html#Adding items to a list. ">EST_TList::Adding items to a list. </A>
<LI><A HREF="EST_TList.html#Constructor functions ">EST_TList::Constructor functions </A>
<LI><A HREF="EST_TList.html#Exchange ">EST_TList::Exchange </A>
<LI><A HREF="EST_TList.html#General functions ">EST_TList::General functions </A>
<LI><A HREF="EST_TList.html#Removing items in a list. ">EST_TList::Removing items in a list. </A>
<LI><A HREF="EST_TMatrix.html#Copy in and out">EST_TMatrix::Copy in and out</A>
<LI><A HREF="EST_TMatrix.html#Sub-Matrix/Vector Extraction">EST_TMatrix::Sub-Matrix/Vector Extraction</A>
<LI><A HREF="EST_TMatrix.html#access">EST_TMatrix::access</A>
<LI><A HREF="EST_TMatrix.html#io">EST_TMatrix::io</A>
<LI><A HREF="EST_Token.html#Basic access to fields ">EST_Token::Basic access to fields </A>
<UL><LI><A HREF="EST_Token.html#Access token as a double ">Access token as a double </A>
<LI><A HREF="EST_Token.html#Access token as a float ">Access token as a float </A>
<LI><A HREF="EST_Token.html#Access token as a int ">Access token as a int </A>
<LI><A HREF="EST_Token.html#Access token as a long ">Access token as a long </A>
<LI><A HREF="EST_Token.html#Access token as a string ">Access token as a string </A>
</UL><LI><A HREF="EST_TokenStream.html#miscellaneous ">EST_TokenStream::miscellaneous </A>
<LI><A HREF="EST_TokenStream.html#stream access functions ">EST_TokenStream::stream access functions </A>
<UL><LI><A HREF="EST_TokenStream.html#get the next token which must be the argument. ">get the next token which must be the argument. </A>
</UL><LI><A HREF="EST_TokenStream.html#stream initialization functions ">EST_TokenStream::stream initialization functions </A>
<LI><A HREF="EST_Track.html#Accessing amplitudes The following functions can be used">EST_Track::Accessing amplitudes The following functions can be used</A>
<LI><A HREF="EST_Track.html#Auxiliary channels">EST_Track::Auxiliary channels</A>
<LI><A HREF="EST_Track.html#Channel information">EST_Track::Channel information</A>
<LI><A HREF="EST_Track.html#Configuring Tracks">EST_Track::Configuring Tracks</A>
<LI><A HREF="EST_Track.html#Constructor and Destructor functions">EST_Track::Constructor and Destructor functions</A>
<LI><A HREF="EST_Track.html#File i/o functions">EST_Track::File i/o functions</A>
<LI><A HREF="EST_Track.html#Functions for sub tracks, channels and frames.">EST_Track::Functions for sub tracks, channels and frames.</A>
<LI><A HREF="EST_Track.html#Global track information">EST_Track::Global track information</A>
<LI><A HREF="EST_Track.html#Timing">EST_Track::Timing</A>
<LI><A HREF="EST_Track.html#Utility functions ">EST_Track::Utility functions </A>
<LI><A HREF="EST_TrackMap.html#ChannelMapping">EST_TrackMap::ChannelMapping</A>
<LI><A HREF="EST_Utterance.html#Constructor and initialisation Functions ">EST_Utterance::Constructor and initialisation Functions </A>
<LI><A HREF="EST_Utterance.html#File i/o ">EST_Utterance::File i/o </A>
<LI><A HREF="EST_Utterance.html#Utility Functions ">EST_Utterance::Utility Functions </A>
<LI><A HREF="EST_Val.html#Constructor and Destructor functions">EST_Val::Constructor and Destructor functions</A>
<LI><A HREF="EST_Val.html#Equivalence test">EST_Val::Equivalence test</A>
<UL><LI><A HREF="EST_Val.html#Automatic casting ">Automatic casting </A>
</UL><LI><A HREF="EST_Val.html#Getting cast values">EST_Val::Getting cast values</A>
<LI><A HREF="EST_Val.html#Setting values">EST_Val::Setting values</A>
<LI><A HREF="EST_WFST.html#Basic WFST operators ">EST_WFST::Basic WFST operators </A>
<LI><A HREF="EST_WFST.html#Constructor and initialisation functions ">EST_WFST::Constructor and initialisation functions </A>
<LI><A HREF="EST_WFST.html#Cumulation functions for adding collective probabilities">EST_WFST::Cumulation functions for adding collective probabilities</A>
<LI><A HREF="EST_WFST.html#General utility functions ">EST_WFST::General utility functions </A>
<LI><A HREF="EST_WFST.html#Reseting functions ">EST_WFST::Reseting functions </A>
<LI><A HREF="EST_WFST.html#WFST construction functions from external represenations *">EST_WFST::WFST construction functions from external represenations *</A>
<LI><A HREF="EST_WFST.html#construction support fuctions ">EST_WFST::construction support fuctions </A>
<LI><A HREF="EST_WFST.html#file i/o ">EST_WFST::file i/o </A>
<LI><A HREF="EST_WFST.html#transduction functions ">EST_WFST::transduction functions </A>
<LI><A HREF="EST_Wave.html#Access functions for finding ampltiudes of samples ">EST_Wave::Access functions for finding ampltiudes of samples </A>
<LI><A HREF="EST_Wave.html#File i/o functions ">EST_Wave::File i/o functions </A>
<LI><A HREF="EST_Wave.html#Information functions ">EST_Wave::Information functions </A>
<LI><A HREF="EST_Wave.html#Waveform manipulation functions ">EST_Wave::Waveform manipulation functions </A>
<LI><A HREF="EST_Window.html#Functions for making windows.">EST_Window::Functions for making windows.</A>
<LI><A HREF="EST_Window.html#Performing windowing on a section of speech. ">EST_Window::Performing windowing on a section of speech. </A>
<LI><A HREF="EST_Window.html#Utility window functions.">EST_Window::Utility window functions.</A>
<LI><A HREF="EST_inline_utils.h.html">EST_inline_utils.h</A>
<LI><A HREF="EST_track_aux.h.html">EST_track_aux.h</A>
<UL><LI><A HREF="Analysisframeposition.html">Analysis frame position</A>
</UL><LI><A HREF="EST_wave_aux.html">EST_wave_aux</A>
<LI><A HREF="Energyandpowerframefunctions.html">Energy and power frame functions</A>
<LI><A HREF="FastFourierTransformfunctions.html">Fast Fourier Transform functions</A>
<LI><A HREF="FilterDesign.html">Filter Design</A>
<LI><A HREF="Framebasedfilterbankandcepstralanalysis.html">Frame based filter bank and cepstral analysis</A>
<UL><LI><A HREF="Frequencyconversionfunctions.html">Frequency conversion functions</A>
</UL><LI><A HREF="Functiontypesusedforparameterstofunctions..html">Function types used for parameters to functions. </A>
<LI><A HREF="Functionsforbuildingandtraversinglistrelations.html">Functions for building and traversing list relations</A>
<UL><LI><A HREF="Listtraversalfunctions.html">List traversal functions </A>
</UL><LI><A HREF="Functionsforbuildingandtraversingtreerelations.html">Functions for building and traversing tree relations</A>
<UL><LI><A HREF="Treebuildingfunctions.html">Tree building functions </A>
<LI><A HREF="Treetraversalfunctions.html">Tree traversal functions </A>
</UL><LI><A HREF="Functionsforusewithframebasedprocessing.html">Functions for use with frame based processing</A>
<LI><A HREF="HashTables.html">Hash Tables</A>
<UL><LI><A HREF="EST_THash.html#Key Iteration">Hash Tables::EST_THash::Key Iteration</A>
<LI><A HREF="EST_THash.html#Pair Iteration">Hash Tables::EST_THash::Pair Iteration</A>
</UL><LI><A HREF="LinearPredictionfilters.html">Linear Prediction filters</A>
<LI><A HREF="LinearPredictionfunctions.html">Linear Prediction functions</A>
<UL><LI><A HREF="AreaFunctions.html">Area Functions</A>
</UL><LI><A HREF="Miscelaneousfilters..html">Miscelaneous filters.</A>
<LI><A HREF="MiscellaneousSignalProcessingFunctions..html">Miscellaneous Signal Processing Functions.</A>
<UL><LI><A HREF="Preemphasis.html">Preemphasis</A>
</UL><LI><A HREF="Noncorefeaturefuntionality..html">Non core feature funtionality.</A>
<LI><A HREF="PitchF0DetectionAlgorithmfunctions.html">Pitch/F0 Detection Algorithm functions</A>
<LI><A HREF="PitchmarkingFunctions.html">Pitchmarking Functions</A>
<LI><A HREF="PrePostEmphasisfilters..html">Pre/Post Emphasis filters.</A>
<LI><A HREF="Predefined_regular_expressions.html">Predefined_regular_expressions</A>
<LI><A HREF="Somegenerallyusefulthings..html">Some generally useful things.</A>
<LI><A HREF="Spectrogramgeneration.html">Spectrogram generation</A>
<LI><A HREF="Templatevector.html">Template vector</A>
<UL><LI><A HREF="EST_TVector.html#access">Template vector::EST_TVector::access</A>
</UL><LI><A HREF="Tiltfunctions.html">Tilt functions</A>
<LI><A HREF="XMLParser.html">XML Parser</A>
<UL><LI><A HREF="XML_Parser_Class.html#Creating a parser">XML Parser::XML_Parser_Class::Creating a parser</A>
<LI><A HREF="XML_Parser_Class.html#The callbacks.">XML Parser::XML_Parser_Class::The callbacks.</A>
</UL><LI><A HREF="anaccumulatortobeownedbyeverymodel.html">an accumulator to be owned by every model</A>
<LI><A HREF="someusefulmatrixcreators.html">some useful matrix creators</A>
</UL>
<H2>Packages</H2>
<UL>
<LI><A HREF="EST_Relation.html#Load relation from already open tokenstream ">EST_Relation::Load relation from already open tokenstream </A>
<LI><A HREF="EST_Relation.html#Return the tail (last) item of the relation ">EST_Relation::Return the tail (last) item of the relation </A>
<LI><A HREF="EST_String.html#Case folded comparison.">Case folded comparison.</A>
<LI><A HREF="EST_TKVL.html#Linked list of key-val pairs.">EST_TKVL::Linked list of key-val pairs.</A>
<LI><A HREF="EST_Viterbi_Decoder.html#(eg.">EST_Viterbi_Decoder::(eg.</A>
<LI><A HREF="EST_Viterbi_Decoder.html#Unfortunately using MAX_DOUBLE doesn't do the right thing">EST_Viterbi_Decoder::Unfortunately using MAX_DOUBLE doesn't do the right thing</A>
</UL>
<H2>Classes</H2>
<UL>
<LI><A HREF="EST_Content_Data.html">EST_Content_Data</A> <I>A class for containing some other (arbitrary) class Not general enough to call itself a run-time type system Is designed to solve the problem of holding user specified information.</I>
<LI><A HREF="EST_Contents.html">EST_Contents</A> <I>More contents </I>
<LI><A HREF="EST_DMatrix.html">EST_DMatrix</A> <I>A matrix class for double precision floating point numbers.</I>
<LI><A HREF="EST_DVector.html">EST_DVector</A> <I>A vector class for double precision floating point numbers.</I>
<LI><A HREF="EST_Discrete.html">EST_Discrete</A> <I>A class for managing mapping string names to integers and back again, mainly used for representing alphabets in n-grams and grammars etc.</I>
<LI><A HREF="EST_DiscreteProbDistribution.html">EST_DiscreteProbDistribution</A> <I>A class for representing probability distributions for a set of discrete values.</I>
<LI><A HREF="EST_FMatrix.html">EST_FMatrix</A> <I>A matrix class for floating point numbers.</I>
<LI><A HREF="EST_FVector.html">EST_FVector</A> <I>A vector class for floating point numbers.</I>
<LI><A HREF="EST_FeatureFunctionPackage.html">EST_FeatureFunctionPackage</A> <I>Represents a named collection of named functions.</I>
<LI><A HREF="EST_FeatureSample.html">EST_FeatureSample</A> <I>A class for containing arbitrary multi-dimensional feature data.</I>
<LI><A HREF="EST_Featured.html">EST_Featured</A> <I>A class with the mechanisms needed to give an object features and access them nicely.</I>
<LI><A HREF="EST_Features.html">EST_Features</A> <I>A class for containing feature structures which can hold atomic values (int, float, string) or other feature structures</I>
<LI><A HREF="EST_FringeServer.html">EST_FringeServer</A> <I>A class providing mechanisms to talk to fringe.</I>
<LI><A HREF="EST_Handleable.html">EST_Handleable</A> <I>Reference Counting Interface.</I>
<LI><A HREF="EST_IMatrix.html">EST_IMatrix</A> <I>A matrix class for integers.</I>
<LI><A HREF="EST_Item.html">EST_Item</A> <I>A class for containing individual linguistic objects such as words or phones.</I>
<LI><A HREF="EST_Item_Content.html">EST_Item_Content</A> <I>A class for containing individual linguistic features and references to relations.</I>
<LI><A HREF="EST_Option.html">EST_Option</A> <I>Provide a high level interface for String String key value lists</I>
<LI><A HREF="EST_Pathname.html">EST_Pathname</A> <I>Class representing pathnames.</I>
<LI><A HREF="EST_Regex.html">EST_Regex</A> <I>A Regular expression class to go with the CSTR EST_String class.</I>
<LI><A HREF="EST_Relation.html">EST_Relation</A> <I>Relations are a container class for EST_Items.</I>
<LI><A HREF="EST_SCFG.html">EST_SCFG</A> <I>A class representing a stochastic context free grammar (SCFG).</I>
<LI><A HREF="EST_SCFG_Chart.html">EST_SCFG_Chart</A> <I>A class for parsing with a probabalistic grammars.</I>
<LI><A HREF="EST_SCFG_Chart_Edge.html">EST_SCFG_Chart_Edge</A> <I>An internal class for <!1><A HREF="EST_SCFG_Chart.html">EST_SCFG_Chart</A> for representing edges in the chart during parsing with SCFGs.</I>
<LI><A HREF="EST_SCFG_Rule.html">EST_SCFG_Rule</A> <I>A stochastic context free grammar rule.</I>
<LI><A HREF="EST_SCFG_traintest.html">EST_SCFG_traintest</A> <I>A class used to train (and test) SCFGs is an extention of <!1><A HREF="EST_SCFG.html">EST_SCFG</A>.</I>
<LI><A HREF="EST_Server.html">EST_Server</A> <I>Client-server interface.</I>
<LI><A HREF="EST_ServiceTable.html">EST_ServiceTable</A> <I>A global table of known services.</I>
<UL><LI><A HREF="Entry.html">EST_ServiceTable::Entry</A> <I>A service record.</I>
</UL><LI><A HREF="EST_SingleChannelWave.html">EST_SingleChannelWave</A> <I>An alias for wave which can be used to tell the compiler you know it is a simple one channel wave.</I>
<LI><A HREF="EST_String.html">EST_String</A> <I>A non-copyleft implementation of a string class to use with compilers that aren't GNU C++.</I>
<LI><A HREF="EST_StringTrie.html">EST_StringTrie</A> <I>A string tree index class for indexing arbitrary objects by strings of characters.</I>
<LI><A HREF="EST_SuffStats.html">EST_SuffStats</A> <I>A class for cummulating ``sufficient statistics'' for a set of numbers: sum, count, sum squared.</I>
<LI><A HREF="EST_TBox.html">EST_TBox</A> <I>Box for putting things in.</I>
<LI><A HREF="EST_TBuffer.html">EST_TBuffer</A> <I>Extending buffer class.</I>
<LI><A HREF="EST_TDeque.html">EST_TDeque</A> <I>Double ended queue.</I>
<LI><A HREF="EST_THandle.html">EST_THandle</A> <I>A `smart' pointer which does reference counting.</I>
<LI><A HREF="EST_TIterator.html">EST_TIterator</A>
<LI><A HREF="EST_TKVI.html">EST_TKVI</A> <I>Templated Key-Value Item.</I>
<LI><A HREF="EST_TKVL.html">EST_TKVL</A> <I>Templated Key-Value list.</I>
<LI><A HREF="EST_TList.html">EST_TList</A>
<LI><A HREF="EST_TMatrix.html">EST_TMatrix</A> <I>Template Matrix class.</I>
<LI><A HREF="EST_TSimpleVector.html">EST_TSimpleVector</A> <I>A derived class from <tt>EST_TVector</tt> which is used for containing simple types, such as <tt>float</tt> or <tt>int</tt></I>
<LI><A HREF="EST_Token.html">EST_Token</A> <I>This class is similar to <!1><A HREF="EST_String.html">EST_String</A> but also maintains the original punctuation and whitespace found around the token.</I>
<LI><A HREF="EST_TokenStream.html">EST_TokenStream</A> <I>A class that allows the reading of <!1><A HREF="EST_Token.html">EST_Token</A>s from a file stream, pipe or string.</I>
<LI><A HREF="EST_Track.html">EST_Track</A> <I>A class for storing time aligned coefficients.</I>
<LI><A HREF="EST_TrackMap.html">EST_TrackMap</A> <I>Track maps provide a mapping from symbolic track names to the actual position of the information within a track frame.</I>
<LI><A HREF="EST_TrieNode.html">EST_TrieNode</A> <I>An internal class for <!1><A HREF="EST_StringTrie.html">EST_StringTrie</A> used to hold represent the node in an string index tree.</I>
<LI><A HREF="EST_Utterance.html">EST_Utterance</A> <I>A class that contains <link linkend="est-item">EST_Items</link> and <link linkend="est-relation">EST_Relations</link> between them.</I>
<LI><A HREF="EST_VTCandidate.html">EST_VTCandidate</A> <I>Internal class to <!1><A HREF="EST_Viterbi_Decoder.html">EST_Viterbi_Decoder</A> used to a represent a candidate.</I>
<LI><A HREF="EST_VTPath.html">EST_VTPath</A> <I>Internal class to <!1><A HREF="EST_Viterbi_Decoder.html">EST_Viterbi_Decoder</A> used to a represent a link in a path the candidates.</I>
<LI><A HREF="EST_VTPoint.html">EST_VTPoint</A> <I>Internal class to \Ref{EST_Viterbi_Decoder used to a node in the decoder table</I>
<LI><A HREF="EST_Val.html">EST_Val</A> <I>The EST_Val class is a container class, used to store a single item which can be an int, float, string or other user-defined class.</I>
<LI><A HREF="EST_Viterbi_Decoder.html">EST_Viterbi_Decoder</A> <I>A class that offers a generalised Viterbi decoder.</I>
<LI><A HREF="EST_WFST.html">EST_WFST</A> <I>a call representing a weighted finite-state transducer</I>
<LI><A HREF="EST_WFST_MultiState.html">EST_WFST_MultiState</A> <I>an internal class to <!1><A HREF="EST_WFST.html">EST_WFST</A> used in holding multi-states when determinizing and find the intersections of other WFSTs</I>
<LI><A HREF="EST_WFST_State.html">EST_WFST_State</A> <I>an internal class for <!1><A HREF="EST_WFST.html">EST_WFST</A> used to represent a state in a WFST </I>
<LI><A HREF="EST_WFST_Transition.html">EST_WFST_Transition</A> <I>an internal class for <!1><A HREF="EST_WFST.html">EST_WFST</A> for representing transitions in an WFST</I>
<LI><A HREF="EST_Wave.html">EST_Wave</A> <I>A class for storing digital waveforms.</I>
<LI><A HREF="EST_Window.html">EST_Window</A> <I>The EST_Window class provides functions for the creation and use of signal processing windows.</I>
<LI><A HREF="EST_bracketed_string.html">EST_bracketed_string</A> <I>This class represents a bracted string used in training of SCFGs.</I>
<LI><A HREF="EST_HashFunctions.html">EST_HashFunctions</A> <I>This is just a convinient place to put some useful hash functions</I>
<LI><A HREF="EST_Hash_Pair.html">EST_Hash_Pair</A> <I>This class is used in hash tables to hold a key value pair.</I>
<LI><A HREF="EST_THash.html">EST_THash</A> <I>An open hash table.</I>
<LI><A HREF="EST_TStringHash.html">EST_TStringHash</A> <I>A specialised hash table for when the key is an EST_String.</I>
<LI><A HREF="Safefeatureaccessfunctions..html">Safe feature access functions.</A>
<LI><A HREF="EST_TVector.html">EST_TVector</A>
<LI><A HREF="XML_Parser.html">XML_Parser</A> <I>An actual parser.</I>
<LI><A HREF="XML_Parser_Class.html">XML_Parser_Class</A> <I>A Class of parsers, All parsers share callbacks and a list of known public IDs</I>
</UL>
<H2>Functions</H2>
<UL>
<LI><A HREF="DefaultHashFunction.html">DefaultHashFunction</A> <I>The default hash function used by <classname>EST_THash</classname></I>
<LI><A HREF="delta.html">delta</A> <I>Produce a set of delta coefficents for a track</I>
<LI><A HREF="sigpr_acc.html">sigpr_acc</A> <I>Produce multiple sets of acceleration coefficents from a waveform</I>
<LI><A HREF="sigpr_delta.html">sigpr_delta</A> <I>Produce multiple sets of delta coefficents from a waveform.</I>
<LI><A HREF="EST_Content_Data.html#ref">EST_Content_Data::ref</A>
<LI><A HREF="EST_Content_Data.html#the_refs">EST_Content_Data::the_refs</A>
<LI><A HREF="EST_Content_Data.html#unref">EST_Content_Data::unref</A>
<LI><A HREF="EST_Contents.html#refs">EST_Contents::refs</A>
<LI><B>EST_DMatrix:</B>
<UL>
<LI><A HREF="EST_DMatrix.html#EST_DMatrix">EST_DMatrix::EST_DMatrix</A> <I>copy constructor</I>
<LI><A HREF="EST_DMatrix.html#EST_DMatrix">EST_DMatrix::EST_DMatrix</A> <I>size constructor</I>
<LI><A HREF="EST_DMatrix.html#EST_DMatrix">EST_DMatrix::EST_DMatrix</A> <I>default constructor</I>
<LI><A HREF="EST_DMatrix.html#EST_DMatrix">EST_DMatrix::EST_DMatrix</A> <I>CHECK - what does this do???</I>
</UL>
<LI><A HREF="EST_DMatrix.html#copyin">EST_DMatrix::copyin</A> <I>Copy 2-d array <TT>x</TT> of size <TT>rows x cols</TT> into matrix</I>
<LI><A HREF="EST_DMatrix.html#est_load">EST_DMatrix::est_load</A> <I>Load from file in est format (binary/ascii defined in file itself)</I>
<LI><A HREF="EST_DMatrix.html#est_save">EST_DMatrix::est_save</A> <I>Save in file in est format</I>
<LI><A HREF="EST_DMatrix.html#load">EST_DMatrix::load</A> <I>Load from file (ascii or binary as defined in file)</I>
<LI><A HREF="EST_DMatrix.html#operator*=">EST_DMatrix::operator*=</A> <I>elementwise multiply by scalar</I>
<LI><A HREF="EST_DMatrix.html#operator+=">EST_DMatrix::operator+=</A> <I>Add elements of 2 same sized matrices</I>
<LI><A HREF="EST_DMatrix.html#operator-=">EST_DMatrix::operator-=</A> <I>Subtract elements of 2 same sized matrices</I>
<LI><A HREF="EST_DMatrix.html#operator/=">EST_DMatrix::operator/=</A> <I>elementwise divide by scalar</I>
<LI><A HREF="EST_DMatrix.html#save">EST_DMatrix::save</A> <I>Save in file (ascii or binary)</I>
<LI><B>EST_DVector:</B>
<UL>
<LI><A HREF="EST_DVector.html#EST_DVector">EST_DVector::EST_DVector</A> <I>Copy constructor</I>
<LI><A HREF="EST_DVector.html#EST_DVector">EST_DVector::EST_DVector</A> <I>Size constructor</I>
<LI><A HREF="EST_DVector.html#EST_DVector">EST_DVector::EST_DVector</A> <I>Default constructor</I>
</UL>
<LI><A HREF="EST_DVector.html#est_load">EST_DVector::est_load</A> <I>Load from file in est format (binary/ascii defined in file itself)</I>
<LI><A HREF="EST_DVector.html#load">EST_DVector::load</A> <I>load vector from file <tt> filename</tt></I>
<LI><B>operator*=:</B>
<UL>
<LI><A HREF="EST_DVector.html#operator*=">EST_DVector::operator*=</A> <I>elementwise multiply by scalar</I>
<LI><A HREF="EST_DVector.html#operator*=">EST_DVector::operator*=</A> <I>elementwise multiply</I>
</UL>
<LI><A HREF="EST_DVector.html#operator+=">EST_DVector::operator+=</A> <I>elementwise add</I>
<LI><A HREF="EST_DVector.html#operator/=">EST_DVector::operator/=</A> <I>elementwise divide by scalar</I>
<LI><A HREF="EST_DVector.html#save">EST_DVector::save</A> <I>save vector to file <tt> filename</tt></I>
<LI><B>EST_Discrete:</B>
<UL>
<LI><A HREF="EST_Discrete.html#EST_Discrete">EST_Discrete::EST_Discrete</A> <I>Initialise discrete class from given list of strings</I>
<LI><A HREF="EST_Discrete.html#EST_Discrete">EST_Discrete::EST_Discrete</A>
<LI><A HREF="EST_Discrete.html#EST_Discrete">EST_Discrete::EST_Discrete</A>
</UL>
<LI><A HREF="EST_Discrete.html#copy">EST_Discrete::copy</A>
<LI><A HREF="EST_Discrete.html#def_val">EST_Discrete::def_val</A> <I>set the default value when a name isn't found (-1 by default)</I>
<LI><A HREF="EST_Discrete.html#index">EST_Discrete::index</A> <I>The int assigned to the given name, if it doesn't exists p_def_val is returned (which is -1 by default)</I>
<LI><A HREF="EST_Discrete.html#init">EST_Discrete::init</A> <I>(re-)initialise</I>
<LI><A HREF="EST_Discrete.html#length">EST_Discrete::length</A> <I>The number of members in the discrete</I>
<LI><B>name:</B>
<UL>
<LI><A HREF="EST_Discrete.html#name">EST_Discrete::name</A> <I>The name given the index</I>
<LI><A HREF="EST_Discrete.html#name">EST_Discrete::name</A> <I>An alternative method for getting the int form the name</I>
</UL>
<LI><A HREF="EST_Discrete.html#operator = ">EST_Discrete::operator = </A>
<LI><A HREF="EST_Discrete.html#~EST_Discrete">EST_Discrete::~EST_Discrete</A>
<LI><B>EST_DiscreteProbDistribution:</B>
<UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#EST_DiscreteProbDistribution">EST_DiscreteProbDistribution::EST_DiscreteProbDistribution</A> <I>Create using given <!1><A HREF="EST_Discrete.html">EST_Discrete</A> class as the vocabulary</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#EST_DiscreteProbDistribution">EST_DiscreteProbDistribution::EST_DiscreteProbDistribution</A> <I>Create with copying from an existing distribution</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#EST_DiscreteProbDistribution">EST_DiscreteProbDistribution::EST_DiscreteProbDistribution</A> <I>Create with given vocabulary</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#EST_DiscreteProbDistribution">EST_DiscreteProbDistribution::EST_DiscreteProbDistribution</A> <I>Create using given <!1><A HREF="EST_Discrete.html">EST_Discrete</A> class as vocabulary plus given counts</I>
</UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#clear">EST_DiscreteProbDistribution::clear</A> <I>Reset, clearing all counts and vocabulary</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#copy">EST_DiscreteProbDistribution::copy</A> <I>Copy all data from another DPD to this</I>
<LI><B>cumulate:</B>
<UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#cumulate">EST_DiscreteProbDistribution::cumulate</A> <I>Add this observation, i must be with in EST_Discrete range</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#cumulate">EST_DiscreteProbDistribution::cumulate</A> <I>Add this observation, may specify number of occurences</I>
</UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#entropy">EST_DiscreteProbDistribution::entropy</A> <I>Return the entropy of the distribution <BR><CENTER><IMG BORDER=0 SRC=g000007.gif><BR></CENTER></I>
<LI><B>frequency:</B>
<UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#frequency">EST_DiscreteProbDistribution::frequency</A>
<LI><A HREF="EST_DiscreteProbDistribution.html#frequency">EST_DiscreteProbDistribution::frequency</A>
</UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#get_discrete">EST_DiscreteProbDistribution::get_discrete</A> <I>Returns discrete vocabilary of distribution</I>
<LI><B>init:</B>
<UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#init">EST_DiscreteProbDistribution::init</A> <I>Initialise</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#init">EST_DiscreteProbDistribution::init</A> <I>Initialise using given vocabulary</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#init">EST_DiscreteProbDistribution::init</A> <I>Initialise using given EST_Distcrete as vocabulary</I>
</UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#item_end">EST_DiscreteProbDistribution::item_end</A> <I>Used for iterating through members of the distribution</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#item_freq">EST_DiscreteProbDistribution::item_freq</A> <I>During iteration ruturns name and frequency given index </I>
<LI><A HREF="EST_DiscreteProbDistribution.html#item_name">EST_DiscreteProbDistribution::item_name</A> <I>During iteration ruturns name given index </I>
<LI><A HREF="EST_DiscreteProbDistribution.html#item_next">EST_DiscreteProbDistribution::item_next</A> <I>Used for iterating through members of the distribution</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#item_prob">EST_DiscreteProbDistribution::item_prob</A> <I>During iteration ruturns name and probability given index</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#item_start">EST_DiscreteProbDistribution::item_start</A> <I>Used for iterating through members of the distribution</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#most_probable">EST_DiscreteProbDistribution::most_probable</A> <I>Return the most probable member of the distribution</I>
<LI><B>override_frequency:</B>
<UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#override_frequency">EST_DiscreteProbDistribution::override_frequency</A> <I>Sets the frequency of named item, without modifying <TT>num_samples</TT></I>
<LI><A HREF="EST_DiscreteProbDistribution.html#override_frequency">EST_DiscreteProbDistribution::override_frequency</A> <I>Sets the frequency of named item, without modifying <TT>num_samples</TT></I>
</UL>
<LI><B>probability:</B>
<UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#probability">EST_DiscreteProbDistribution::probability</A>
<LI><A HREF="EST_DiscreteProbDistribution.html#probability">EST_DiscreteProbDistribution::probability</A>
</UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#samples">EST_DiscreteProbDistribution::samples</A> <I>Total number of example found</I>
<LI><B>set_frequency:</B>
<UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#set_frequency">EST_DiscreteProbDistribution::set_frequency</A> <I>Sets the frequency of named item, modifes <TT>num_samples</TT> accordingly.</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#set_frequency">EST_DiscreteProbDistribution::set_frequency</A> <I>Sets the frequency of named item, modifes <TT>num_samples</TT> accordingly.</I>
</UL>
<LI><A HREF="EST_DiscreteProbDistribution.html#set_num_samples">EST_DiscreteProbDistribution::set_num_samples</A> <I>Sets the number of samples.</I>
<LI><A HREF="EST_DiscreteProbDistribution.html#~EST_DiscreteProbDistribution">EST_DiscreteProbDistribution::~EST_DiscreteProbDistribution</A> <I>Destructor function</I>
<LI><B>EST_FMatrix:</B>
<UL>
<LI><A HREF="EST_FMatrix.html#EST_FMatrix">EST_FMatrix::EST_FMatrix</A> <I>size constructor</I>
<LI><A HREF="EST_FMatrix.html#EST_FMatrix">EST_FMatrix::EST_FMatrix</A> <I>copy constructor</I>
<LI><A HREF="EST_FMatrix.html#EST_FMatrix">EST_FMatrix::EST_FMatrix</A> <I>CHECK - what does this do???</I>
<LI><A HREF="EST_FMatrix.html#EST_FMatrix">EST_FMatrix::EST_FMatrix</A> <I>default constructor</I>
</UL>
<LI><A HREF="EST_FMatrix.html#copyin">EST_FMatrix::copyin</A> <I>Copy 2-d array <TT>x</TT> of size <TT>rows x cols</TT> into matrix</I>
<LI><A HREF="EST_FMatrix.html#est_load">EST_FMatrix::est_load</A> <I>Load from file in est format (binary/ascii defined in file itself)</I>
<LI><A HREF="EST_FMatrix.html#est_save">EST_FMatrix::est_save</A> <I>Save in file in est format</I>
<LI><A HREF="EST_FMatrix.html#load">EST_FMatrix::load</A> <I>Load from file (ascii or binary as defined in file)</I>
<LI><A HREF="EST_FMatrix.html#operator*=">EST_FMatrix::operator*=</A> <I>elementwise multiply by scalar</I>
<LI><A HREF="EST_FMatrix.html#operator+=">EST_FMatrix::operator+=</A> <I>Add elements of 2 same sized matrices</I>
<LI><A HREF="EST_FMatrix.html#operator-=">EST_FMatrix::operator-=</A> <I>Subtract elements of 2 same sized matrices</I>
<LI><A HREF="EST_FMatrix.html#operator/=">EST_FMatrix::operator/=</A> <I>elementwise divide by scalar</I>
<LI><A HREF="EST_FMatrix.html#save">EST_FMatrix::save</A> <I>Save in file (ascii or binary)</I>
<LI><B>EST_FVector:</B>
<UL>
<LI><A HREF="EST_FVector.html#EST_FVector">EST_FVector::EST_FVector</A> <I>Size constructor</I>
<LI><A HREF="EST_FVector.html#EST_FVector">EST_FVector::EST_FVector</A> <I>Copy constructor</I>
<LI><A HREF="EST_FVector.html#EST_FVector">EST_FVector::EST_FVector</A> <I>Default constructor</I>
</UL>
<LI><A HREF="EST_FVector.html#est_load">EST_FVector::est_load</A> <I>Load from file in est format (binary/ascii defined in file itself)</I>
<LI><A HREF="EST_FVector.html#load">EST_FVector::load</A> <I>load vector from file <tt> filename</tt></I>
<LI><B>operator*=:</B>
<UL>
<LI><A HREF="EST_FVector.html#operator*=">EST_FVector::operator*=</A> <I>elementwise multiply</I>
<LI><A HREF="EST_FVector.html#operator*=">EST_FVector::operator*=</A> <I>elementwise multiply by scalar</I>
</UL>
<LI><A HREF="EST_FVector.html#operator+=">EST_FVector::operator+=</A> <I>elementwise add</I>
<LI><A HREF="EST_FVector.html#operator/=">EST_FVector::operator/=</A> <I>elementwise divide by scalar</I>
<LI><A HREF="EST_FVector.html#save">EST_FVector::save</A> <I>save vector to file <tt> filename</tt></I>
<LI><B>f:</B>
<UL>
<LI><A HREF="EST_Features.html#f">f</A> <I>Look up feature name, which may be simple feature or path</I>
<LI><A HREF="EST_Features.html#f">f</A> <I>Look up feature name, which may be simple feature or path, returning <parameter>def</paramater> if not found</I>
</UL>
<LI><B>operator() :</B>
<UL>
<LI><A HREF="EST_Features.html#operator() ">operator() </A> <I>Look up feature name, which may be simple feature or path</I>
<LI><A HREF="EST_Features.html#operator() ">operator() </A> <I>Look up feature name, which may be simple feature or path, returning <parameter>def</paramater> if not found</I>
</UL>
<LI><B>val:</B>
<UL>
<LI><A HREF="EST_Features.html#val">val</A> <I>Look up directly without decomposing name as path (just simple feature)</I>
<LI><A HREF="EST_Features.html#val">val</A> <I>Look up directly without decomposing name as path (just simple feature), returning <parameter>def</paramater> if not found</I>
</UL>
<LI><B>val_path:</B>
<UL>
<LI><A HREF="EST_Features.html#val_path">val_path</A> <I>Look up feature name, which may be simple feature or path</I>
<LI><A HREF="EST_Features.html#val_path">val_path</A> <I>Look up feature name, which may be simple feature or path, returning <parameter>def</paramater> if not found</I>
</UL>
<LI><B>A:</B>
<UL>
<LI><A HREF="EST_Features.html#A">A</A> <I>Look up feature name, which may be simple feature or path, and return as a EST_Features </I>
<LI><A HREF="EST_Features.html#A">A</A> <I>Look up feature name, which may be simple feature or path, and return as a EST_Features, returning <parameter>def</paramater> if not found </I>
</UL>
<LI><B>F:</B>
<UL>
<LI><A HREF="EST_Features.html#F">F</A> <I>Look up feature name, which may be simple feature or path, and return as a float </I>
<LI><A HREF="EST_Features.html#F">F</A> <I>Look up feature name, which may be simple feature or path, and return as a float, returning <parameter>def</paramater> if not found </I>
</UL>
<LI><B>I:</B>
<UL>
<LI><A HREF="EST_Features.html#I">I</A> <I>Look up feature name, which may be simple feature or path, and return as an int </I>
<LI><A HREF="EST_Features.html#I">I</A> <I>Look up feature name, which may be simple feature or path, and return as an int, returning <parameter>def</paramater> if not found </I>
</UL>
<LI><B>S:</B>
<UL>
<LI><A HREF="EST_Features.html#S">S</A> <I>Look up feature name, which may be simple feature or path, and return as a EST_String, returning <parameter>def</paramater> if not found </I>
<LI><A HREF="EST_Features.html#S">S</A> <I>Look up feature name, which may be simple feature or path, and return as a EST_String </I>
</UL>
<LI><A HREF="EST_Features.html#load">load</A> <I>load features from already opened EST_TokenStream</I>
<LI><A HREF="EST_Features.html#load_sexpr">load_sexpr</A> <I>load features from sexpression, contained in already opened EST_TokenStream </I>
<LI><A HREF="EST_Features.html#save">save</A> <I>save features in already opened ostream</I>
<LI><A HREF="EST_Features.html#save_sexpr">save_sexpr</A> <I>save features as s-expression in already opened ostream</I>
<LI><B>set:</B>
<UL>
<LI><A HREF="EST_Features.html#set">set</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>dval</parameter></I>
<LI><A HREF="EST_Features.html#set">set</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>ival</parameter></I>
<LI><A HREF="EST_Features.html#set">set</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>fval</parameter></I>
<LI><A HREF="EST_Features.html#set">set</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>f</parameter>, which itself is a EST_Features.</I>
<LI><A HREF="EST_Features.html#set">set</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>sval</parameter></I>
<LI><A HREF="EST_Features.html#set">set</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>cval</parameter></I>
</UL>
<LI><A HREF="EST_Features.html#set_function">set_function</A> <I>Add a new feature feature or set an existing feature <parameter>name<parameter> to value <parameter>f</parameter>, which is the named of a registered feature function</I>
<LI><A HREF="EST_Features.html#set_path">set_path</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>val<parameter>, where <parameter>name<parameter> is a path</I>
<LI><A HREF="EST_Features.html#set_val">set_val</A> <I>Add a new feature or set an existing feature <parameter>name<parameter> to value <parameter>val<parameter>.</I>
<LI><A HREF="EST_Features.html#clear">clear</A> <I>Delete all features from object </I>
<LI><A HREF="EST_Features.html#f.save">f.save</A>
<LI><A HREF="EST_Features.html#length">length</A> <I>number of features in feature structure </I>
<LI><A HREF="EST_Features.html#operator = ">operator = </A> <I>Feature assignment </I>
<LI><A HREF="EST_Features.html#present">present</A> <I>return 1 if the feature is present </I>
<LI><A HREF="EST_Features.html#remove">remove</A> <I>remove the named feature </I>
<LI><B>EST_FringeServer:</B>
<UL>
<LI><A HREF="EST_FringeServer.html#EST_FringeServer">EST_FringeServer::EST_FringeServer</A> <I>Create a server connection by name, defaulting to "fringe", the default server name</I>
<LI><A HREF="EST_FringeServer.html#EST_FringeServer">EST_FringeServer::EST_FringeServer</A> <I>Create a server connection by explicitly saying where to connect to</I>
</UL>
<LI><A HREF="EST_FringeServer.html#~EST_FringeServer">EST_FringeServer::~EST_FringeServer</A> <I>Destroy the connection</I>
<LI><B>EST_IMatrix:</B>
<UL>
<LI><A HREF="EST_IMatrix.html#EST_IMatrix">EST_IMatrix::EST_IMatrix</A> <I>CHECK - what does this do???</I>
<LI><A HREF="EST_IMatrix.html#EST_IMatrix">EST_IMatrix::EST_IMatrix</A> <I>size constructor</I>
<LI><A HREF="EST_IMatrix.html#EST_IMatrix">EST_IMatrix::EST_IMatrix</A> <I>copy constructor</I>
<LI><A HREF="EST_IMatrix.html#EST_IMatrix">EST_IMatrix::EST_IMatrix</A> <I>default constructor</I>
</UL>
<LI><B>EST_Item:</B>
<UL>
<LI><A HREF="EST_Item.html#EST_Item">EST_Item</A> <I>Most common form of construction</I>
<LI><A HREF="EST_Item.html#EST_Item">EST_Item</A> <I>Default constructor</I>
<LI><A HREF="EST_Item.html#EST_Item">EST_Item</A> <I>Copy constructure only makes reference to contents </I>
<LI><A HREF="EST_Item.html#EST_Item">EST_Item</A> <I>Includes reference to relation </I>
</UL>
<LI><A HREF="EST_Item.html#~EST_Item">~EST_Item</A> <I>Deletes it and references to it in its contents</I>
<LI><A HREF="EST_Item.html#as_relation">as_relation</A> <I>View item from another relation (const char *) method</I>
<LI><A HREF="EST_Item.html#in_relation">in_relation</A> <I>TRUE if this item is in named relation</I>
<LI><A HREF="EST_Item.html#relation">relation</A> <I>The relation of this particular item</I>
<LI><A HREF="EST_Item.html#relation_name">relation_name</A> <I>The relation name of this particular item</I>
<LI><A HREF="EST_Item.html#relations">relations</A> <I>Access to the relation links</I>
<LI><A HREF="EST_Item.html#same_item">same_item</A> <I>True if li is the same item ignoring its relation viewpoint</I>
<LI><B>A:</B>
<UL>
<LI><A HREF="EST_Item.html#A">A</A> <I>return the value of the feature <parameter>name</parameter> cast as a EST_Features </I>
<LI><A HREF="EST_Item.html#A">A</A> <I>return the value of the feature <parameter>name</parameter> cast as a EST_Features, returning <parameter>def</parameter> if not found</I>
</UL>
<LI><B>F:</B>
<UL>
<LI><A HREF="EST_Item.html#F">F</A> <I>return the value of the feature <parameter>name</parameter> cast as a float </I>
<LI><A HREF="EST_Item.html#F">F</A> <I>return the value of the feature <parameter>name</parameter> cast as a float, returning <parameter>def</parameter> if not found</I>
</UL>
<LI><B>I:</B>
<UL>
<LI><A HREF="EST_Item.html#I">I</A> <I>return the value of the feature <parameter>name</parameter> cast as a int </I>
<LI><A HREF="EST_Item.html#I">I</A> <I>return the value of the feature <parameter>name</parameter> cast as a int returning <parameter>def</parameter> if not found</I>
</UL>
<LI><B>S:</B>
<UL>
<LI><A HREF="EST_Item.html#S">S</A> <I>return the value of the feature <parameter>name</parameter> cast as a EST_String </I>
<LI><A HREF="EST_Item.html#S">S</A> <I>return the value of the feature <parameter>name</parameter> cast as a EST_String, returning <parameter>def</parameter> if not found</I>
</UL>
<LI><B>set:</B>
<UL>
<LI><A HREF="EST_Item.html#set">set</A> <I>set feature <parameter>name</parameter> to <parameter>f</parameter>, a set of features, which is copied into the object</I>
<LI><A HREF="EST_Item.html#set">set</A> <I>set feature <parameter>name</parameter> to <parameter>val</parameter> </I>
<LI><A HREF="EST_Item.html#set">set</A> <I>set feature <parameter>name</parameter> to <parameter>val</parameter> </I>
<LI><A HREF="EST_Item.html#set">set</A> <I>set feature <parameter>name</parameter> to <parameter>val</parameter> </I>
<LI><A HREF="EST_Item.html#set">set</A> <I>set feature <parameter>name</parameter> to <parameter>val</parameter> </I>
<LI><A HREF="EST_Item.html#set">set</A> <I>set feature <parameter>name</parameter> to <parameter>val</parameter> </I>
</UL>
<LI><A HREF="EST_Item.html#set_function">set_function</A> <I>set feature <parameter>name</parameter> to <parameter>val</parameter>, a function registered in the feature function list.</I>
<LI><A HREF="EST_Item.html#set_val">set_val</A> <I>set feature <parameter>name</parameter> to <parameter>f</parameter>, whose type is EST_Val</I>
<LI><A HREF="EST_Item.html#evaluate_features">evaluate_features</A> <I>find all the attributes whose values are functions, and replace them with their evaluation.</I>
<LI><A HREF="EST_Item.html#f_present">f_present</A> <I>TRUE if feature is present, FALSE otherwise </I>
<LI><A HREF="EST_Item.html#f_remove">f_remove</A> <I>remove feature <parameter>name</parameter> </I>
<LI><B>EST_Item_Content:</B>
<UL>
<LI><A HREF="EST_Item_Content.html#EST_Item_Content">EST_Item_Content</A> <I>Copy constructor</I>
<LI><A HREF="EST_Item_Content.html#EST_Item_Content">EST_Item_Content</A> <I>Default constructor</I>
</UL>
<LI><A HREF="EST_Item_Content.html#~EST_Item_Content">~EST_Item_Content</A> <I>destructor</I>
<LI><A HREF="EST_Item_Content.html#name">EST_Item_Content::name</A> <I>return the name of the item, eg.</I>
<LI><A HREF="EST_Item_Content.html#set_name">EST_Item_Content::set_name</A> <I>set name</I>
<LI><A HREF="EST_Option.html#add_iitem">EST_Option::add_iitem</A> <I>return value of type String relating to key.</I>
<LI><A HREF="EST_Option.html#add_prefix">EST_Option::add_prefix</A> <I>add prefix to every key </I>
<LI><A HREF="EST_Option.html#dval">EST_Option::dval</A> <I>return value of type float relating to key.</I>
<LI><A HREF="EST_Option.html#fval">EST_Option::fval</A> <I>return value of type float relating to key.</I>
<LI><A HREF="EST_Option.html#ival">EST_Option::ival</A> <I>return value of type int relating to key.</I>
<LI><A HREF="EST_Option.html#load">EST_Option::load</A> <I>read keyval list from file.</I>
<LI><A HREF="EST_Option.html#override_fval">EST_Option::override_fval</A> <I>add to end of list or overwrite.</I>
<LI><A HREF="EST_Option.html#override_ival">EST_Option::override_ival</A> <I>add to end of list or overwrite.</I>
<LI><A HREF="EST_Option.html#override_val">EST_Option::override_val</A> <I>add to end of list or overwrite.</I>
<LI><A HREF="EST_Option.html#remove_prefix">EST_Option::remove_prefix</A> <I>remove prefix from every key </I>
<LI><A HREF="EST_Option.html#sval">EST_Option::sval</A> <I>return value of type String relating to key.</I>
<LI><B>operator = :</B>
<UL>
<LI><A HREF="EST_Regex.html#operator = ">operator = </A>
<LI><A HREF="EST_Regex.html#operator = ">operator = </A>
<LI><A HREF="EST_Regex.html#operator = ">operator = </A>
</UL>
<LI><B>EST_Regex:</B>
<UL>
<LI><A HREF="EST_Regex.html#EST_Regex">EST_Regex::EST_Regex</A> <I>Copy constructor</I>
<LI><A HREF="EST_Regex.html#EST_Regex">EST_Regex::EST_Regex</A> <I>Empty constructor, just for form</I>
<LI><A HREF="EST_Regex.html#EST_Regex">EST_Regex::EST_Regex</A> <I>Construct from EST_String</I>
<LI><A HREF="EST_Regex.html#EST_Regex">EST_Regex::EST_Regex</A> <I>Construct from C string</I>
</UL>
<LI><A HREF="EST_Regex.html#compile">EST_Regex::compile</A> <I>Compile expression</I>
<LI><A HREF="EST_Regex.html#compile_match">EST_Regex::compile_match</A> <I>Compile expression in a form which only matches whole string</I>
<LI><A HREF="EST_Regex.html#operator const char *">EST_Regex::operator const char *</A> <I>Cast operator, disambiguates it for some compilers</I>
<LI><A HREF="EST_Regex.html#regularize">EST_Regex::regularize</A> <I>Translate the expression into the internally used syntax</I>
<LI><A HREF="EST_Regex.html#run">EST_Regex::run</A> <I>Run to find a matching substring</I>
<LI><A HREF="EST_Regex.html#run_match">EST_Regex::run_match</A> <I>Run to see if it matches the entire string</I>
<LI><A HREF="EST_Regex.html#size">EST_Regex::size</A> <I>Size of the expression</I>
<LI><A HREF="EST_Regex.html#tostring">EST_Regex::tostring</A> <I>Get the expression as a string</I>
<LI><A HREF="EST_Regex.html#~EST_Regex">EST_Regex::~EST_Regex</A> <I>Destructor</I>
<LI><B>EST_Relation:</B>
<UL>
<LI><A HREF="EST_Relation.html#EST_Relation">EST_Relation::EST_Relation</A> <I>Constructor which copies relation r </I>
<LI><A HREF="EST_Relation.html#EST_Relation">EST_Relation::EST_Relation</A> <I>default constructor </I>
<LI><A HREF="EST_Relation.html#EST_Relation">EST_Relation::EST_Relation</A> <I>Constructor which sets name of relation </I>
</UL>
<LI><A HREF="EST_Relation.html#clear">EST_Relation::clear</A> <I>Clear the relation of items </I>
<LI><A HREF="EST_Relation.html#empty">EST_Relation::empty</A> <I>return true if relation does not contain any items </I>
<LI><A HREF="EST_Relation.html#evaluate_features">EST_Relation::evaluate_features</A> <I>Evaluate the relation's feature functions </I>
<LI><A HREF="EST_Relation.html#evaluate_item_features">EST_Relation::evaluate_item_features</A> <I>Evaluate the feature functions of all the items in the relation </I>
<LI><A HREF="EST_Relation.html#head">EST_Relation::head</A> <I>Return the head (first) item of the relation </I>
<LI><B>load:</B>
<UL>
<LI><A HREF="EST_Relation.html#load">EST_Relation::load</A> <I>Load relation from already open tokenstream </I>
<LI><A HREF="EST_Relation.html#load">EST_Relation::load</A> <I>Load relation from file </I>
</UL>
<LI><A HREF="EST_Relation.html#name">EST_Relation::name</A> <I>Return the name of the relation </I>
<LI><A HREF="EST_Relation.html#remove_item">EST_Relation::remove_item</A> <I>remove EST_Item <parameter>item</parameter> from relation </I>
<LI><A HREF="EST_Relation.html#remove_item_feature">EST_Relation::remove_item_feature</A> <I>remove all occurances of feature <parameter>name</parameter> from relation's items</I>
<LI><A HREF="EST_Relation.html#root">EST_Relation::root</A> <I>Return the root item of the relation </I>
<LI><B>save:</B>
<UL>
<LI><A HREF="EST_Relation.html#save">EST_Relation::save</A> <I>Save relation from already open ostream </I>
<LI><A HREF="EST_Relation.html#save">EST_Relation::save</A> <I>Save relation to file </I>
<LI><A HREF="EST_Relation.html#save">EST_Relation::save</A> <I>Save relation to file, evaluating all feature functions before hand </I>
<LI><A HREF="EST_Relation.html#save">EST_Relation::save</A> <I>Save relation from already open ostream </I>
</UL>
<LI><A HREF="EST_Relation.html#set_utt">EST_Relation::set_utt</A> <I>Set the <link linkend="est-utterance">EST_Utterance</link> to which this relation belongs </I>
<LI><A HREF="EST_Relation.html#tail">EST_Relation::tail</A> <I>Return the tail (last) item of the relation </I>
<LI><A HREF="EST_Relation.html#utt">EST_Relation::utt</A> <I>Return the <link linkend="est-utterance">EST_Utterance</link> to which this relation belongs </I>
<LI><A HREF="EST_Relation.html#~EST_Relation">EST_Relation::~EST_Relation</A> <I>default destructor </I>
<LI><A HREF="EST_SCFG.html#EST_SCFG">EST_SCFG</A> <I>Initialize from a set of rules</I>
<LI><A HREF="EST_SCFG.html#load">load</A> <I>Load grammar from named file</I>
<LI><A HREF="EST_SCFG.html#save">save</A> <I>Save current grammar to named file</I>
<LI><A HREF="EST_SCFG.html#find_terms_nonterms">find_terms_nonterms</A> <I>Find the terminals and nonterminals in the given grammar, adding them to the appropriate given string lists</I>
<LI><A HREF="EST_SCFG.html#get_rules">get_rules</A> <I>Return rules as LISP list</I>
<LI><B>nonterminal:</B>
<UL>
<LI><A HREF="EST_SCFG.html#nonterminal">nonterminal</A> <I>Convert nonterminal string to index</I>
<LI><A HREF="EST_SCFG.html#nonterminal">nonterminal</A> <I>Convert nonterminal index to string form</I>
</UL>
<LI><A HREF="EST_SCFG.html#num_nonterminals">num_nonterminals</A> <I>Number of nonterminals</I>
<LI><A HREF="EST_SCFG.html#num_terminals">num_terminals</A> <I>Number of terminals</I>
<LI><A HREF="EST_SCFG.html#prob_B">prob_B</A> <I>The rule probability of given binary rule</I>
<LI><A HREF="EST_SCFG.html#prob_U">prob_U</A> <I>The rule probability of given unary rule</I>
<LI><A HREF="EST_SCFG.html#set_rule_prob_cache">set_rule_prob_cache</A> <I>(re-)set rule probability caches</I>
<LI><A HREF="EST_SCFG.html#set_rules">set_rules</A> <I>Set (or reset) rules from external source after construction</I>
<LI><B>terminal:</B>
<UL>
<LI><A HREF="EST_SCFG.html#terminal">terminal</A> <I>Convert terminal string to index</I>
<LI><A HREF="EST_SCFG.html#terminal">terminal</A> <I>Convert terminal index to string form</I>
</UL>
<LI><B>set_grammar_rules:</B>
<UL>
<LI><A HREF="EST_SCFG_Chart.html#set_grammar_rules">set_grammar_rules</A> <I>Initialize from existing <!1><A HREF="EST_SCFG.html">EST_SCFG</A> grammar</I>
<LI><A HREF="EST_SCFG_Chart.html#set_grammar_rules">set_grammar_rules</A> <I>Initialize from LISP rules set</I>
</UL>
<LI><B>setup_wfst:</B>
<UL>
<LI><A HREF="EST_SCFG_Chart.html#setup_wfst">setup_wfst</A> <I>Initialize for parsing from relation using <TT>name</TT> feature setting up the "Well Fromed Substring Table" </I>
<LI><A HREF="EST_SCFG_Chart.html#setup_wfst">setup_wfst</A> <I>Initialize for parsing from s to e using <TT>name</TT> feature setting up the "Well Fromed Substring Table" </I>
</UL>
<LI><B>extract_parse:</B>
<UL>
<LI><A HREF="EST_SCFG_Chart.html#extract_parse">extract_parse</A> <I>Extract parse tree and add it to syn linking leafs to word</I>
<LI><A HREF="EST_SCFG_Chart.html#extract_parse">extract_parse</A> <I>Extract parse tree and add it to syn linking leafs to items s to e</I>
</UL>
<LI><A HREF="EST_SCFG_Chart.html#find_parse">find_parse</A> <I>Return the parse in full LISP form</I>
<LI><A HREF="EST_SCFG_Chart.html#parse">parse</A> <I>Parses the loaded WFST with the loaded grammar</I>
<LI><A HREF="EST_SCFG_Chart_Edge.html#d1">EST_SCFG_Chart_Edge::d1</A> <I>(Non)terminal of daughter 1</I>
<LI><A HREF="EST_SCFG_Chart_Edge.html#d2">EST_SCFG_Chart_Edge::d2</A> <I>(Non)terminal of daughter 2</I>
<LI><A HREF="EST_SCFG_Chart_Edge.html#pos">EST_SCFG_Chart_Edge::pos</A> <I>Postion, 0 1 or 2, where 0 is empty, 1 is incomplete 2 is complete</I>
<LI><A HREF="EST_SCFG_Chart_Edge.html#prob">EST_SCFG_Chart_Edge::prob</A> <I>Edge probability</I>
<LI><B>EST_SCFG_Rule:</B>
<UL>
<LI><A HREF="EST_SCFG_Rule.html#EST_SCFG_Rule">EST_SCFG_Rule::EST_SCFG_Rule</A> <I>Create a binary rule</I>
<LI><A HREF="EST_SCFG_Rule.html#EST_SCFG_Rule">EST_SCFG_Rule::EST_SCFG_Rule</A>
<LI><A HREF="EST_SCFG_Rule.html#EST_SCFG_Rule">EST_SCFG_Rule::EST_SCFG_Rule</A>
<LI><A HREF="EST_SCFG_Rule.html#EST_SCFG_Rule">EST_SCFG_Rule::EST_SCFG_Rule</A> <I>Create a unary rule</I>
</UL>
<LI><A HREF="EST_SCFG_Rule.html#daughter1">EST_SCFG_Rule::daughter1</A> <I>In a unary rule this is a terminal, in a binary rule it is a nonterminal</I>
<LI><A HREF="EST_SCFG_Rule.html#daughter2">EST_SCFG_Rule::daughter2</A>
<LI><A HREF="EST_SCFG_Rule.html#mother">EST_SCFG_Rule::mother</A>
<LI><A HREF="EST_SCFG_Rule.html#prob">EST_SCFG_Rule::prob</A> <I>The rule's probability</I>
<LI><A HREF="EST_SCFG_Rule.html#set_prob">EST_SCFG_Rule::set_prob</A> <I>set the probability</I>
<LI><B>set_rule:</B>
<UL>
<LI><A HREF="EST_SCFG_Rule.html#set_rule">EST_SCFG_Rule::set_rule</A>
<LI><A HREF="EST_SCFG_Rule.html#set_rule">EST_SCFG_Rule::set_rule</A>
</UL>
<LI><A HREF="EST_SCFG_Rule.html#type">EST_SCFG_Rule::type</A> <I>rule type</I>
<LI><A HREF="EST_SCFG_chart_load_relation.html">EST_SCFG_chart_load_relation</A> <I>Build a relation from a LISP list of items</I>
<LI><A HREF="EST_SCFG_traintest.html#clear_io_cache">EST_SCFG_traintest::clear_io_cache</A> <I>Clear the cache for inside/outside values for sentence <TT>c</TT></I>
<LI><A HREF="EST_SCFG_traintest.html#cross_entropy">EST_SCFG_traintest::cross_entropy</A>
<LI><A HREF="EST_SCFG_traintest.html#f_I">EST_SCFG_traintest::f_I</A> <I>Lookup or caculate inside probability</I>
<LI><A HREF="EST_SCFG_traintest.html#f_I_cal">EST_SCFG_traintest::f_I_cal</A> <I>Caculate inside probability</I>
<LI><A HREF="EST_SCFG_traintest.html#f_O">EST_SCFG_traintest::f_O</A> <I>Lookup or caculate outside probability</I>
<LI><A HREF="EST_SCFG_traintest.html#f_O_cal">EST_SCFG_traintest::f_O_cal</A> <I>Caculate outside probability</I>
<LI><B>f_P:</B>
<UL>
<LI><A HREF="EST_SCFG_traintest.html#f_P">EST_SCFG_traintest::f_P</A> <I>Find probability of parse of corpus sentence <TT>c</TT></I>
<LI><A HREF="EST_SCFG_traintest.html#f_P">EST_SCFG_traintest::f_P</A> <I>Find probability of parse of corpus sentence <TT>c</TT> for nonterminal <TT>p</TT></I>
</UL>
<LI><A HREF="EST_SCFG_traintest.html#init_io_cache">EST_SCFG_traintest::init_io_cache</A> <I>Initialize the cache for inside/outside values for sentence <TT>c</TT></I>
<LI><A HREF="EST_SCFG_traintest.html#load_corpus">EST_SCFG_traintest::load_corpus</A> <I>Load a corpus from the given file.</I>
<LI><A HREF="EST_SCFG_traintest.html#reestimate_grammar_probs">EST_SCFG_traintest::reestimate_grammar_probs</A> <I>Do grammar restimation</I>
<LI><A HREF="EST_SCFG_traintest.html#reestimate_rule_prob_B">EST_SCFG_traintest::reestimate_rule_prob_B</A> <I>Re-estimate probability of binary rule using iniside-outside algorithm</I>
<LI><A HREF="EST_SCFG_traintest.html#reestimate_rule_prob_U">EST_SCFG_traintest::reestimate_rule_prob_U</A> <I>Re-estimate probability of unary rule using iniside-outside algorithm</I>
<LI><A HREF="EST_SCFG_traintest.html#test_corpus">EST_SCFG_traintest::test_corpus</A> <I>Test the current grammar against the current corpus print summary.</I>
<LI><A HREF="EST_SCFG_traintest.html#test_crossbrackets">EST_SCFG_traintest::test_crossbrackets</A> <I>Test the current grammar against the current corpus.</I>
<LI><A HREF="EST_SCFG_traintest.html#train_inout">EST_SCFG_traintest::train_inout</A> <I>Train a grammar using the loaded corpus.</I>
<LI><B>EST_Server:</B>
<UL>
<LI><A HREF="EST_Server.html#EST_Server">EST_Server</A> <I>Create a server connection by explicitly saying where to connect to</I>
<LI><A HREF="EST_Server.html#EST_Server">EST_Server</A> <I>Create a server connection by name, defaulting to "fringe", the default server name</I>
</UL>
<LI><A HREF="EST_Server.html#connect">connect</A> <I>Connect to the server</I>
<LI><A HREF="EST_Server.html#connected">connected</A> <I>Are we connected at the moment?</I>
<LI><A HREF="EST_Server.html#disconnect">disconnect</A> <I>Disconnect</I>
<LI><A HREF="EST_Server.html#address">address</A> <I>Dotted numeric IP address</I>
<LI><A HREF="EST_Server.html#hostname">hostname</A> <I>Domain name of the server</I>
<LI><A HREF="EST_Server.html#name">name</A> <I>Name of server</I>
<LI><A HREF="EST_Server.html#port">port</A> <I>Port number</I>
<LI><A HREF="EST_Server.html#servername">servername</A> <I>Domain name or IP number</I>
<LI><A HREF="EST_Server.html#type">type</A> <I>Type of server</I>
<LI><A HREF="EST_Server.html#~EST_Server">EST_Server::~EST_Server</A> <I>Destroy the connection</I>
<LI><A HREF="Entry.html#Entry">EST_ServiceTable::Entry::Entry</A> <I>Create an empty entry</I>
<LI><A HREF="Entry.html#operator EST_String">EST_ServiceTable::Entry::operator EST_String</A> <I>A suitable human readable name for the entry</I>
<LI><A HREF="EST_ServiceTable.html#list">list</A> <I>List the table to given stream</I>
<LI><A HREF="EST_ServiceTable.html#names">names</A> <I>Return a list of server names</I>
<LI><B>read_table:</B>
<UL>
<LI><A HREF="EST_ServiceTable.html#read_table">read_table</A> <I>Read the users default table.</I>
<LI><A HREF="EST_ServiceTable.html#read_table">read_table</A> <I>Read a specific table</I>
</UL>
<LI><B>write_table:</B>
<UL>
<LI><A HREF="EST_ServiceTable.html#write_table">write_table</A> <I>Write the users default table.</I>
<LI><A HREF="EST_ServiceTable.html#write_table">write_table</A> <I>Write a specific table</I>
</UL>
<LI><A HREF="EST_ServiceTable.html#create">EST_ServiceTable::create</A> <I>Create an entry for a server of the given name and type which is listening on the given socket</I>
<LI><A HREF="EST_ServiceTable.html#lookup">EST_ServiceTable::lookup</A> <I>Return the entry for the server with the given name and type.</I>
<LI><A HREF="EST_SingleChannelWave.html#EST_SingleChannelWave">EST_SingleChannelWave::EST_SingleChannelWave</A> <I>default constructor</I>
<LI><B>after:</B>
<UL>
<LI><A HREF="EST_String.html#after">after</A> <I>Part after substring</I>
<LI><A HREF="EST_String.html#after">after</A> <I>Part after substring</I>
<LI><A HREF="EST_String.html#after">after</A> <I>Part after pos+len</I>
<LI><A HREF="EST_String.html#after">after</A> <I>Part after match of regular expression</I>
</UL>
<LI><B>at:</B>
<UL>
<LI><A HREF="EST_String.html#at">at</A> <I>Return part at position</I>
<LI><A HREF="EST_String.html#at">at</A> <I>Return part where substring found (not useful, included for completeness)</I>
<LI><A HREF="EST_String.html#at">at</A> <I>Return part where substring found (not useful, included for completeness)</I>
<LI><A HREF="EST_String.html#at">at</A> <I>Return part matching regexp</I>
</UL>
<LI><B>before:</B>
<UL>
<LI><A HREF="EST_String.html#before">before</A> <I>Part before first match of regexp after pos</I>
<LI><A HREF="EST_String.html#before">before</A> <I>Part before position</I>
<LI><A HREF="EST_String.html#before">before</A> <I>Part before first matching substring after pos</I>
<LI><A HREF="EST_String.html#before">before</A> <I>Part before first matching substring after pos</I>
</UL>
<LI><B>chop_internal:</B>
<UL>
<LI><A HREF="EST_String.html#chop_internal">chop_internal</A> <I>Locate subsring and chop</I>
<LI><A HREF="EST_String.html#chop_internal">chop_internal</A> <I>Chop at given position</I>
<LI><A HREF="EST_String.html#chop_internal">chop_internal</A> <I>Locate match for expression and chop</I>
</UL>
<LI><B>contains:</B>
<UL>
<LI><A HREF="EST_String.html#contains">contains</A> <I>Does it contain this substring?</I>
<LI><A HREF="EST_String.html#contains">contains</A> <I>Does it contain this substring?</I>
<LI><A HREF="EST_String.html#contains">contains</A> <I>Does it contain this character?</I>
<LI><A HREF="EST_String.html#contains">contains</A> <I>Does it contain a match for this regular expression?</I>
</UL>
<LI><B>matches:</B>
<UL>
<LI><A HREF="EST_String.html#matches">matches</A> <I>Exactly matches this regular expression, can return ends of sub-expressions</I>
<LI><A HREF="EST_String.html#matches">matches</A> <I>Exatly match this string?</I>
<LI><A HREF="EST_String.html#matches">matches</A> <I>Exatly match this string?</I>
</UL>
<LI><A HREF="EST_String.html#Double">EST_String::Double</A> <I>Convert to a double</I>
<LI><B>EST_String:</B>
<UL>
<LI><A HREF="EST_String.html#EST_String">EST_String::EST_String</A> <I>Construct from single char.</I>
<LI><A HREF="EST_String.html#EST_String">EST_String::EST_String</A> <I>private constructor which uses the buffer given</I>
<LI><A HREF="EST_String.html#EST_String">EST_String::EST_String</A> <I>Construct an empty string</I>
<LI><A HREF="EST_String.html#EST_String">EST_String::EST_String</A> <I>Construct from char *</I>
<LI><A HREF="EST_String.html#EST_String">EST_String::EST_String</A> <I>Construct from part of char * or fill with given character</I>
<LI><A HREF="EST_String.html#EST_String">EST_String::EST_String</A> <I>Construct from C string</I>
<LI><A HREF="EST_String.html#EST_String">EST_String::EST_String</A> <I>Copy constructor We have to declare our own copy constructor to lie to the compier about the constness of the RHS</I>
</UL>
<LI><B>locate:</B>
<UL>
<LI><A HREF="EST_String.html#locate">locate</A> <I>Find match for regexp</I>
<LI><A HREF="EST_String.html#locate">locate</A> <I>Find substring </I>
<LI><A HREF="EST_String.html#locate">locate</A> <I>Find substring</I>
</UL>
<LI><A HREF="EST_String.html#Float">EST_String::Float</A> <I>Convert to a float</I>
<LI><B>freq:</B>
<UL>
<LI><A HREF="EST_String.html#freq">freq</A> <I>Number of occurances of substring</I>
<LI><A HREF="EST_String.html#freq">freq</A> <I>Number of occurances of substring</I>
<LI><A HREF="EST_String.html#freq">freq</A> <I>Number of matches of regular expression</I>
</UL>
<LI><A HREF="EST_String.html#FromChar">EST_String::FromChar</A> <I>Build string from a single character</I>
<LI><B>index:</B>
<UL>
<LI><A HREF="EST_String.html#index">index</A> <I>Position of match of regexp (starting at pos)</I>
<LI><A HREF="EST_String.html#index">index</A> <I>Position of substring (starting at pos)</I>
<LI><A HREF="EST_String.html#index">index</A> <I>Position of substring (starting at pos)</I>
</UL>
<LI><B>gsub:</B>
<UL>
<LI><A HREF="EST_String.html#gsub">gsub</A> <I>Substitute string for matches of regular expression</I>
<LI><A HREF="EST_String.html#gsub">gsub</A> <I>Substitute one string for another</I>
<LI><A HREF="EST_String.html#gsub">gsub</A> <I>Substitute one string for another</I>
<LI><A HREF="EST_String.html#gsub">gsub</A> <I>Substitute one string for another</I>
<LI><A HREF="EST_String.html#gsub">gsub</A> <I>Substitute one string for another</I>
<LI><A HREF="EST_String.html#gsub">gsub</A> <I>Substitute string for matches of regular expression</I>
<LI><A HREF="EST_String.html#gsub">gsub</A> <I>Substitute string for matches of regular expression</I>
</UL>
<LI><A HREF="EST_String.html#subst">subst</A> <I>Substitute the result of a match into a string</I>
<LI><B>gsub_internal:</B>
<UL>
<LI><A HREF="EST_String.html#gsub_internal">gsub_internal</A> <I>Substitute for matches of regexp</I>
<LI><A HREF="EST_String.html#gsub_internal">gsub_internal</A> <I>Substitute for string</I>
</UL>
<LI><A HREF="EST_String.html#Int">EST_String::Int</A> <I>Convert to an integer</I>
<LI><A HREF="EST_String.html#Long">EST_String::Long</A> <I>Convert to a long</I>
<LI><A HREF="EST_String.html#NON_CONST_CHUNKPTR">EST_String::NON_CONST_CHUNKPTR</A> <I>Simple utility which removes const-ness frommemory</I>
<LI><B>Number:</B>
<UL>
<LI><A HREF="EST_String.html#Number">EST_String::Number</A> <I>Build string from an integer</I>
<LI><A HREF="EST_String.html#Number">EST_String::Number</A> <I>Build string from a float</I>
<LI><A HREF="EST_String.html#Number">EST_String::Number</A> <I>Build string from a long integer</I>
<LI><A HREF="EST_String.html#Number">EST_String::Number</A> <I>Build string from a double</I>
</UL>
<LI><B>operator += :</B>
<UL>
<LI><A HREF="EST_String.html#operator += ">operator += </A> <I>Add EST_String to end of EST_String</I>
<LI><A HREF="EST_String.html#operator += ">operator += </A> <I>Add C string to end of EST_String</I>
</UL>
<LI><B>operator = :</B>
<UL>
<LI><A HREF="EST_String.html#operator = ">operator = </A> <I>Assign EST_String to EST_String</I>
<LI><A HREF="EST_String.html#operator = ">operator = </A> <I>Assign C string to EST_String</I>
<LI><A HREF="EST_String.html#operator = ">operator = </A> <I>Assign single character to EST_String</I>
</UL>
<LI><A HREF="EST_String.html#operator () ">operator () </A> <I>Function style access to constant strings</I>
<LI><A HREF="EST_String.html#operator [] ">operator [] </A> <I>Array style access to writable strings</I>
<LI><A HREF="EST_String.html#operator char*">operator char*</A> <I>Cast to char *, may involve copying</I>
<LI><A HREF="EST_String.html#operator const char*">operator const char*</A> <I>Cast to const char * by simply giving access to pointer</I>
<LI><A HREF="EST_String.html#compare">compare</A>
<LI><A HREF="EST_String.html#return">return</A>
<LI><A HREF="EST_String.html#quote">quote</A> <I>Return the string in quotes with internal quotes protected</I>
<LI><A HREF="EST_String.html#quote_if_needed">quote_if_needed</A> <I>Return in quotes if there is something to protect (eg.</I>
<LI><A HREF="EST_String.html#unquote">unquote</A> <I>Remove quotes and unprotect internal quotes</I>
<LI><A HREF="EST_String.html#unquote_if_needed">unquote_if_needed</A> <I>Remove quotes if any</I>
<LI><B>search:</B>
<UL>
<LI><A HREF="EST_String.html#search">search</A> <I>Find a match of the regular expression</I>
<LI><A HREF="EST_String.html#search">search</A> <I>Find a substring</I>
<LI><A HREF="EST_String.html#search">search</A> <I>Find a substring</I>
</UL>
<LI><A HREF="EST_String.html#fcompare">EST_String::String comparison.::Case folded comparison.::fcompare</A>
<LI><A HREF="EST_String.html#compare">compare</A>
<LI><A HREF="EST_String.html#cat">EST_String::cat</A> <I>Concatenate a number of strings.</I>
<LI><A HREF="EST_String.html#length">EST_String::length</A> <I>Length of string (<EM>not</EM> length of underlying chunk)</I>
<LI><A HREF="EST_String.html#shareing">EST_String::shareing</A> <I>Is more than one String represented by the same memory?</I>
<LI><A HREF="EST_String.html#space">EST_String::space</A> <I>Size of underlying chunk</I>
<LI><A HREF="EST_String.html#split_internal">EST_String::split_internal</A> <I>Split the string down into parts.</I>
<LI><A HREF="EST_String.html#str">EST_String::str</A> <I>Get a const-pointer to the actual memory</I>
<LI><A HREF="EST_String.html#updatable_str">EST_String::updatable_str</A> <I>Get a writable pointer to the actual memory</I>
<LI><A HREF="EST_String.html#~EST_String">EST_String::~EST_String</A> <I>Destructor</I>
<LI><B>EST_StringTrie:</B>
<UL>
<LI><A HREF="EST_StringTrie.html#EST_StringTrie">EST_StringTrie::EST_StringTrie</A>
<LI><A HREF="EST_StringTrie.html#EST_StringTrie">EST_StringTrie::EST_StringTrie</A>
</UL>
<LI><A HREF="EST_StringTrie.html#add">EST_StringTrie::add</A> <I>Add <TT>item</TT> indexed by <TT>key</TT>, overwriting previous contents</I>
<LI><A HREF="EST_StringTrie.html#clear">EST_StringTrie::clear</A> <I>Delete the tree, apply <TT>deletenote</TT> function to each <TT>contents</TT>Delete the tree</I>
<LI><A HREF="EST_StringTrie.html#copy">EST_StringTrie::copy</A>
<LI><A HREF="EST_StringTrie.html#lookup">EST_StringTrie::lookup</A> <I>Find contents index by <TT>key</TT>, 0 if there is not contents</I>
<LI><A HREF="EST_StringTrie.html#operator = ">EST_StringTrie::operator = </A>
<LI><A HREF="EST_StringTrie.html#~EST_StringTrie">EST_StringTrie::~EST_StringTrie</A>
<LI><B>EST_SuffStats:</B>
<UL>
<LI><A HREF="EST_SuffStats.html#EST_SuffStats">EST_SuffStats::EST_SuffStats</A>
<LI><A HREF="EST_SuffStats.html#EST_SuffStats">EST_SuffStats::EST_SuffStats</A>
</UL>
<LI><A HREF="EST_SuffStats.html#copy">EST_SuffStats::copy</A>
<LI><A HREF="EST_SuffStats.html#mean">EST_SuffStats::mean</A> <I>mean of currently cummulated values</I>
<LI><A HREF="EST_SuffStats.html#operator + ">EST_SuffStats::operator + </A> <I>Used to cummulate new values</I>
<LI><A HREF="EST_SuffStats.html#operator +=">EST_SuffStats::operator +=</A> <I>Used to cummulate new values</I>
<LI><A HREF="EST_SuffStats.html#operator = ">EST_SuffStats::operator = </A>
<LI><A HREF="EST_SuffStats.html#reset">EST_SuffStats::reset</A> <I>reset internal values</I>
<LI><A HREF="EST_SuffStats.html#samples">EST_SuffStats::samples</A> <I>number of samples in set</I>
<LI><A HREF="EST_SuffStats.html#stddev">EST_SuffStats::stddev</A> <I>standard deviation of currently cummulated values</I>
<LI><A HREF="EST_SuffStats.html#sum">EST_SuffStats::sum</A> <I>sum of values</I>
<LI><A HREF="EST_SuffStats.html#sumx">EST_SuffStats::sumx</A> <I>sum of squared values </I>
<LI><A HREF="EST_SuffStats.html#variance">EST_SuffStats::variance</A> <I>variance of currently cummulated values </I>
<LI><A HREF="EST_TBox.html#EST_TBox">EST_TBox::EST_TBox</A> <I>This never happens</I>
<LI><B>b:</B>
<UL>
<LI><A HREF="EST_TBuffer.html#b">b</A> <I>Simple access as a pointer</I>
<LI><A HREF="EST_TBuffer.html#b">b</A> <I>Read-only access when the EST_TBuffer is a constant</I>
</UL>
<LI><A HREF="EST_TBuffer.html#operator() ">operator() </A> <I>operator () is simple access</I>
<LI><A HREF="EST_TBuffer.html#EST_TBuffer">EST_TBuffer.h::EST_TBuffer::EST_TBuffer</A> <I>Create with size and increment.</I>
<LI><B>ensure:</B>
<UL>
<LI><A HREF="EST_TBuffer.html#ensure">ensure</A> <I>Make sure there is enough space, copying if requested</I>
<LI><A HREF="EST_TBuffer.html#ensure">ensure</A> <I>Extend if needed, copying existing data</I>
<LI><A HREF="EST_TBuffer.html#ensure">ensure</A> <I>Make sure there is enough space, setting to a known value</I>
</UL>
<LI><B>expand_to:</B>
<UL>
<LI><A HREF="EST_TBuffer.html#expand_to">EST_TBuffer.h::EST_TBuffer::expand_to</A> <I>Expand and set some of it to a known value</I>
<LI><A HREF="EST_TBuffer.html#expand_to">EST_TBuffer.h::EST_TBuffer::expand_to</A> <I>Expand the buffer</I>
</UL>
<LI><A HREF="EST_TBuffer.html#init">EST_TBuffer.h::EST_TBuffer::init</A> <I>Setup code</I>
<LI><A HREF="EST_TBuffer.html#length">EST_TBuffer.h::EST_TBuffer::length</A> <I>Current available space</I>
<LI><A HREF="EST_TBuffer.html#set">EST_TBuffer.h::EST_TBuffer::set</A> <I>Set to the given value.</I>
<LI><A HREF="EST_TBuffer.html#~EST_TBuffer">EST_TBuffer.h::EST_TBuffer::~EST_TBuffer</A> <I>Destructor.</I>
<LI><A HREF="EST_TDeque.html#clear">EST_TDeque::clear</A> <I>Empty it out</I>
<LI><A HREF="EST_TDeque.html#is_empty">EST_TDeque::is_empty</A> <I>Is there anything to get?</I>
<LI><A HREF="EST_TDeque.html#print">EST_TDeque::print</A> <I>print picture of state.</I>
<LI><A HREF="EST_TIterator.html#current">current</A> <I>Return the element currentl pointed to</I>
<LI><A HREF="EST_TIterator.html#n">n</A> <I>Return the current position</I>
<LI><A HREF="EST_TIterator.html#next_element">next_element</A> <I>Return the current element and move the pointer forwards</I>
<LI><A HREF="EST_TIterator.html#operator *">operator *</A> <I>The * operator returns the current element.</I>
<LI><B>EST_TIterator:</B>
<UL>
<LI><A HREF="EST_TIterator.html#EST_TIterator">EST_TIterator::EST_TIterator</A> <I>Create an iterator ready to run over the given container</I>
<LI><A HREF="EST_TIterator.html#EST_TIterator">EST_TIterator::EST_TIterator</A> <I>Create an iterator not associated with any specific container</I>
</UL>
<LI><A HREF="EST_TIterator.html#at_end">at_end</A> <I>True when there are no more</I>
<LI><A HREF="EST_TIterator.html#has_more_elements">has_more_elements</A> <I>True if there are more elements to look at</I>
<LI><A HREF="EST_TIterator.html#operator int">operator int</A> <I>Viewing the iterator as an integer (for instance in a test) sees a non-zero value iff there are elements still to look at</I>
<LI><A HREF="EST_TIterator.html#next">next</A> <I>Next moves to the next entry</I>
<LI><A HREF="EST_TIterator.html#operator ++">operator ++</A> <I>The increment operator does the same as next</I>
<LI><A HREF="EST_TIterator.html#begin">EST_TIterator::begin</A> <I>Set the iterator ready to run over this container</I>
<LI><A HREF="EST_TIterator.html#beginning">EST_TIterator::beginning</A> <I>Reset to the start of the container</I>
<LI><B>operator = :</B>
<UL>
<LI><A HREF="EST_TIterator.html#operator = ">EST_TIterator::operator = </A> <I>Assigning a container to an iterator sets it ready to start</I>
<LI><A HREF="EST_TIterator.html#operator = ">EST_TIterator::operator = </A> <I>Copy an iterator by assignment</I>
</UL>
<LI><A HREF="EST_TKVL.html#add_item">add_item</A> <I>add key-val pair to list</I>
<LI><A HREF="EST_TKVL.html#change_key">change_key</A> <I>change name of key pair</I>
<LI><B>change_val:</B>
<UL>
<LI><A HREF="EST_TKVL.html#change_val">change_val</A> <I>change key-val pair.</I>
<LI><A HREF="EST_TKVL.html#change_val">change_val</A> <I>change key-val pair.</I>
</UL>
<LI><B>key:</B>
<UL>
<LI><A HREF="EST_TKVL.html#key">key</A> <I>return first matching key, referenced by val</I>
<LI><A HREF="EST_TKVL.html#key">key</A> <I>find key, reference by ptr </I>
<LI><A HREF="EST_TKVL.html#key">key</A> <I>find key, reference by ptr </I>
</UL>
<LI><A HREF="EST_TKVL.html#remove_item">remove_item</A> <I>remove key and val pair from list</I>
<LI><B>val:</B>
<UL>
<LI><A HREF="EST_TKVL.html#val">val</A> <I>return value according to ptr</I>
<LI><A HREF="EST_TKVL.html#val">val</A> <I>return value according to key (const)</I>
<LI><A HREF="EST_TKVL.html#val">val</A> <I>return value according to key (non-const)</I>
<LI><A HREF="EST_TKVL.html#val">val</A> <I>return value according to ptr</I>
</UL>
<LI><A HREF="EST_TKVL.html#val_def">val_def</A> <I>value or default </I>
<LI><B>EST_TKVL:</B>
<UL>
<LI><A HREF="EST_TKVL.html#EST_TKVL">EST_TKVL</A> <I>copy constructor</I>
<LI><A HREF="EST_TKVL.html#EST_TKVL">EST_TKVL</A> <I>default constructor</I>
</UL>
<LI><A HREF="EST_TKVL.html#clear">EST_TKVL::clear</A> <I>Empty list</I>
<LI><A HREF="EST_TKVL.html#head">EST_TKVL::head</A> <I>Return First key value pair in list</I>
<LI><A HREF="EST_TKVL.html#length">EST_TKVL::length</A> <I>number of key value pairs in list</I>
<LI><A HREF="EST_TKVL.html#map">EST_TKVL::map</A> <I>apply function to each pair</I>
<LI><A HREF="EST_TKVL.html#operator + ">EST_TKVL::operator + </A> <I>make new concatenated list</I>
<LI><A HREF="EST_TKVL.html#operator += ">EST_TKVL::operator += </A> <I>add kv after existing list</I>
<LI><A HREF="EST_TKVL.html#operator = ">EST_TKVL::operator = </A> <I>full copy of KV list</I>
<LI><A HREF="EST_TKVL.html#present">EST_TKVL::present</A> <I>Returns true if key is present</I>
<LI><B>first:</B>
<UL>
<LI><A HREF="EST_TList.html#first">first</A> <I>return reference to first item in list </I>
<LI><A HREF="EST_TList.html#first">first</A> <I>return const reference to first item in list</I>
</UL>
<LI><B>item:</B>
<UL>
<LI><A HREF="EST_TList.html#item">item</A> <I>return a const value associated with the EST_Litem pointer</I>
<LI><A HREF="EST_TList.html#item">item</A> <I>return the value associated with the EST_Litem pointer.</I>
</UL>
<LI><B>last:</B>
<UL>
<LI><A HREF="EST_TList.html#last">last</A> <I>return const reference to last item in list</I>
<LI><A HREF="EST_TList.html#last">last</A> <I>return reference to last item in list</I>
</UL>
<LI><B>nth:</B>
<UL>
<LI><A HREF="EST_TList.html#nth">nth</A> <I>return the Nth value</I>
<LI><A HREF="EST_TList.html#nth">nth</A> <I>return a const Nth value</I>
</UL>
<LI><B>operator () :</B>
<UL>
<LI><A HREF="EST_TList.html#operator () ">operator () </A> <I>return const reference to item in list pointed to by <TT>ptr</TT></I>
<LI><A HREF="EST_TList.html#operator () ">operator () </A> <I>return const reference to item in list pointed to by <TT>ptr</TT></I>
</UL>
<LI><A HREF="EST_TList.html#append">append</A> <I>add item onto end of list</I>
<LI><A HREF="EST_TList.html#insert_after">insert_after</A> <I>add <TT>item</TT> after position given by <TT>ptr</TT>, return pointer to added item.</I>
<LI><A HREF="EST_TList.html#insert_before">insert_before</A> <I>add <TT>item</TT> before position given by <TT>ptr</TT>, return pointer to added item.</I>
<LI><A HREF="EST_TList.html#prepend">prepend</A> <I>add item onto start of list</I>
<LI><B>EST_TList:</B>
<UL>
<LI><A HREF="EST_TList.html#EST_TList">EST_TList</A> <I>copy constructor</I>
<LI><A HREF="EST_TList.html#EST_TList">EST_TList</A> <I>default constructor</I>
</UL>
<LI><B>exchange:</B>
<UL>
<LI><A HREF="EST_TList.html#exchange">exchange</A> <I>exchange 2</I>
<LI><A HREF="EST_TList.html#exchange">exchange</A> <I>exchange 1</I>
</UL>
<LI><A HREF="EST_TList.html#exchange_contents">exchange_contents</A> <I>exchange 3 </I>
<LI><A HREF="EST_TList.html#clear">clear</A> <I>remove all items in list</I>
<LI><A HREF="EST_TList.html#operator +=">operator +=</A> <I>Add list onto end of existing list</I>
<LI><A HREF="EST_TList.html#operator=">operator=</A> <I>make full copy of list</I>
<LI><A HREF="EST_TList.html#remove">remove</A> <I>remove item pointed to by <TT>ptr</TT>, return pointer to previous item.</I>
<LI><A HREF="EST_TList.html#remove_nth">remove_nth</A> <I>remove nth item, return pointer to previous item</I>
<LI><B>copy_column:</B>
<UL>
<LI><A HREF="EST_TMatrix.html#copy_column">copy_column</A> <I>Copy column <TT>c</TT> of matrix to <TT>buf</TT>.</I>
<LI><A HREF="EST_TMatrix.html#copy_column">copy_column</A> <I>Copy column <parameter>c</parameter> of matrix to <parameter>buf</parameter>.</I>
</UL>
<LI><B>copy_row:</B>
<UL>
<LI><A HREF="EST_TMatrix.html#copy_row">copy_row</A> <I>Copy row <parameter>r</parameter> of matrix to <parameter>buf</parameter>.</I>
<LI><A HREF="EST_TMatrix.html#copy_row">copy_row</A> <I>Copy row <TT>r</TT> of matrix to <TT>buf</TT>.</I>
</UL>
<LI><A HREF="EST_TMatrix.html#set_column">set_column</A> <I>Copy buf into column <TT>n</TT> of matrix.</I>
<LI><A HREF="EST_TMatrix.html#set_memory">set_memory</A> <I>For when you absolutely have to have access to the memory</I>
<LI><A HREF="EST_TMatrix.html#set_row">set_row</A> <I>Copy buf into row <TT>n</TT> of matrix.</I>
<LI><B>EST_TMatrix:</B>
<UL>
<LI><A HREF="EST_TMatrix.html#EST_TMatrix">EST_TMatrix::EST_TMatrix</A> <I>"size" constructor</I>
<LI><A HREF="EST_TMatrix.html#EST_TMatrix">EST_TMatrix::EST_TMatrix</A> <I>default constructor</I>
<LI><A HREF="EST_TMatrix.html#EST_TMatrix">EST_TMatrix::EST_TMatrix</A> <I>copy constructor</I>
<LI><A HREF="EST_TMatrix.html#EST_TMatrix">EST_TMatrix::EST_TMatrix</A> <I>construct from memory supplied by caller</I>
</UL>
<LI><A HREF="EST_TMatrix.html#column">column</A> <I>Make the vector <TT>cv</TT> a window onto column <TT>c</TT></I>
<LI><A HREF="EST_TMatrix.html#row">row</A> <I>Make the vector <TT>rv</TT> a window onto row <TT>r</TT></I>
<LI><A HREF="EST_TMatrix.html#sub_matrix">sub_matrix</A> <I>Make the matrix <TT>sm</TT> a window into this matrix</I>
<LI><B>a_check:</B>
<UL>
<LI><A HREF="EST_TMatrix.html#a_check">a_check</A> <I>const element access function </I>
<LI><A HREF="EST_TMatrix.html#a_check">a_check</A> <I>non-const element access function </I>
</UL>
<LI><B>a_no_check:</B>
<UL>
<LI><A HREF="EST_TMatrix.html#a_no_check">a_no_check</A> <I>const access with no bounds check, care recommend</I>
<LI><A HREF="EST_TMatrix.html#a_no_check">a_no_check</A> <I>access with no bounds check, care recommend</I>
</UL>
<LI><A HREF="EST_TMatrix.html#num_columns">num_columns</A> <I>return number of columns</I>
<LI><A HREF="EST_TMatrix.html#num_rows">num_rows</A> <I>return number of rows</I>
<LI><B>operator () :</B>
<UL>
<LI><A HREF="EST_TMatrix.html#operator () ">operator () </A> <I>non-const element access operator</I>
<LI><A HREF="EST_TMatrix.html#operator () ">operator () </A> <I>const element access operator</I>
</UL>
<LI><A HREF="EST_TMatrix.html#add_rows">EST_TMatrix::add_rows</A> <I>The two versions of what might have been operator +=</I>
<LI><A HREF="EST_TMatrix.html#copy">EST_TMatrix::copy</A> <I>private resize and copy function.</I>
<LI><A HREF="EST_TMatrix.html#copy_data">EST_TMatrix::copy_data</A> <I>just copy data, no resizing, no size check</I>
<LI><A HREF="EST_TMatrix.html#default_vals">EST_TMatrix::default_vals</A> <I>sets data and length to default values (0 in both cases)</I>
<LI><A HREF="EST_TMatrix.html#fast_a_m">EST_TMatrix::fast_a_m</A> <I>quick method for returning <TT>x[m][n]</TT></I>
<LI><A HREF="EST_TMatrix.html#fill">EST_TMatrix::fill</A> <I>fill matrix with value v</I>
<LI><A HREF="EST_TMatrix.html#load">load</A> <I>load Matrix from file - Not currently implemented</I>
<LI><A HREF="EST_TMatrix.html#save">save</A> <I>save Matrix to file <TT>filename</TT></I>
<LI><A HREF="EST_TMatrix.html#just_resize">EST_TMatrix::just_resize</A> <I>resize the memory and reset the bounds, but don't set values</I>
<LI><A HREF="EST_TMatrix.html#operator=">EST_TMatrix::operator=</A> <I>assignment operator</I>
<LI><A HREF="EST_TMatrix.html#resize">EST_TMatrix::resize</A> <I>resize matrix.</I>
<LI><A HREF="EST_TMatrix.html#set_values">EST_TMatrix::set_values</A> <I>Get and set values from array</I>
<LI><A HREF="EST_TMatrix.html#~EST_TMatrix">EST_TMatrix::~EST_TMatrix</A> <I>EST_TMatrix</I>
<LI><B>EST_TSimpleVector:</B>
<UL>
<LI><A HREF="EST_TSimpleVector.html#EST_TSimpleVector">EST_TSimpleVector::EST_TSimpleVector</A> <I>"size" constructor</I>
<LI><A HREF="EST_TSimpleVector.html#EST_TSimpleVector">EST_TSimpleVector::EST_TSimpleVector</A> <I>default constructor</I>
<LI><A HREF="EST_TSimpleVector.html#EST_TSimpleVector">EST_TSimpleVector::EST_TSimpleVector</A> <I>copy constructor</I>
</UL>
<LI><A HREF="EST_TSimpleVector.html#copy">EST_TSimpleVector::copy</A> <I>private copy function</I>
<LI><A HREF="EST_TSimpleVector.html#empty">EST_TSimpleVector::empty</A> <I>Fill vector with default value</I>
<LI><A HREF="EST_TSimpleVector.html#operator=">EST_TSimpleVector::operator=</A> <I>assignment operator</I>
<LI><A HREF="EST_TSimpleVector.html#resize">EST_TSimpleVector::resize</A> <I>resize vector</I>
<LI><A HREF="EST_TSimpleVector.html#zero">EST_TSimpleVector::zero</A> <I>Fill entire array with 0 bits.</I>
<LI><A HREF="EST_Token.html#quoted">EST_Token::::quoted</A> <I>TRUE is token was quoted</I>
<LI><A HREF="EST_Token.html#set_quoted">EST_Token::::set_quoted</A> <I>Note that this token was quoted (or not)</I>
<LI><A HREF="EST_Token.html#S">S</A> <I>Access token as a string</I>
<LI><A HREF="EST_Token.html#String">String</A> <I>Access token as a string</I>
<LI><A HREF="EST_Token.html#operator EST_String">operator EST_String</A> <I>For automatic coercion to <!1><A HREF="EST_String.html">EST_String</A></I>
<LI><A HREF="EST_Token.html#prepunctuation">prepunctuation</A>
<LI><A HREF="EST_Token.html#punctuation">punctuation</A>
<LI><B>set_prepunctuation:</B>
<UL>
<LI><A HREF="EST_Token.html#set_prepunctuation">set_prepunctuation</A>
<LI><A HREF="EST_Token.html#set_prepunctuation">set_prepunctuation</A> <I>set prepunction</I>
</UL>
<LI><B>set_punctuation:</B>
<UL>
<LI><A HREF="EST_Token.html#set_punctuation">set_punctuation</A> <I>set (post) punctuation of token</I>
<LI><A HREF="EST_Token.html#set_punctuation">set_punctuation</A>
</UL>
<LI><B>set_token:</B>
<UL>
<LI><A HREF="EST_Token.html#set_token">set_token</A> <I>set token from a string</I>
<LI><A HREF="EST_Token.html#set_token">set_token</A>
</UL>
<LI><B>set_whitespace:</B>
<UL>
<LI><A HREF="EST_Token.html#set_whitespace">set_whitespace</A>
<LI><A HREF="EST_Token.html#set_whitespace">set_whitespace</A> <I>set whitespace of token</I>
</UL>
<LI><A HREF="EST_Token.html#whitespace">whitespace</A>
<LI><B>EST_Token:</B>
<UL>
<LI><A HREF="EST_Token.html#EST_Token">EST_Token::EST_Token</A>
<LI><A HREF="EST_Token.html#EST_Token">EST_Token::EST_Token</A>
</UL>
<LI><A HREF="EST_Token.html#col">EST_Token::col</A> <I>Line position in original <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A></I>
<LI><A HREF="EST_Token.html#filepos">EST_Token::filepos</A> <I>file position in original <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A></I>
<LI><A HREF="EST_Token.html#init">EST_Token::init</A>
<LI><A HREF="EST_Token.html#lstring">EST_Token::lstring</A> <I>Return lower case version of token name</I>
<LI><B>operator != :</B>
<UL>
<LI><A HREF="EST_Token.html#operator != ">EST_Token::operator != </A>
<LI><A HREF="EST_Token.html#operator != ">EST_Token::operator != </A>
</UL>
<LI><B>operator = :</B>
<UL>
<LI><A HREF="EST_Token.html#operator = ">EST_Token::operator = </A>
<LI><A HREF="EST_Token.html#operator = ">EST_Token::operator = </A>
</UL>
<LI><B>operator == :</B>
<UL>
<LI><A HREF="EST_Token.html#operator == ">EST_Token::operator == </A>
<LI><A HREF="EST_Token.html#operator == ">EST_Token::operator == </A>
</UL>
<LI><A HREF="EST_Token.html#pos_description">EST_Token::pos_description</A> <I>A string describing current position, suitable for error messages</I>
<LI><A HREF="EST_Token.html#row">EST_Token::row</A> <I>Line number in original <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A></I>
<LI><A HREF="EST_Token.html#set_col">EST_Token::set_col</A>
<LI><A HREF="EST_Token.html#set_filepos">EST_Token::set_filepos</A> <I>Set file position in original <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A></I>
<LI><A HREF="EST_Token.html#set_row">EST_Token::set_row</A>
<LI><A HREF="EST_Token.html#ustring">EST_Token::ustring</A> <I>Return upper case version of token name</I>
<LI><A HREF="EST_TokenStream.html#close">EST_TokenStream::::close</A> <I>Close stream</I>
<LI><B>open:</B>
<UL>
<LI><A HREF="EST_TokenStream.html#open">EST_TokenStream::::open</A> <I>open a <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A> for an already open istream</I>
<LI><A HREF="EST_TokenStream.html#open">EST_TokenStream::::open</A> <I>open a <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A> for a file</I>
<LI><A HREF="EST_TokenStream.html#open">EST_TokenStream::::open</A> <I>open a <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A> for an already opened file</I>
</UL>
<LI><A HREF="EST_TokenStream.html#open_string">EST_TokenStream::::open_string</A> <I>open a <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A> for string rather than a file</I>
<LI><B>EST_TokenStream:</B>
<UL>
<LI><A HREF="EST_TokenStream.html#EST_TokenStream">EST_TokenStream::EST_TokenStream</A>
<LI><A HREF="EST_TokenStream.html#EST_TokenStream">EST_TokenStream::EST_TokenStream</A> <I>This function is deliberately private so that you'll get a compilation error if you assign a token stream or pass it as an (non-reference) argument.</I>
</UL>
<LI><A HREF="EST_TokenStream.html#eof">eof</A> <I>end of file</I>
<LI><A HREF="EST_TokenStream.html#eoln">eoln</A> <I>end of line</I>
<LI><A HREF="EST_TokenStream.html#filedescriptor">filedescriptor</A> <I>For the people who *need* the actual description (if possible)</I>
<LI><A HREF="EST_TokenStream.html#filename">filename</A> <I>The originating filename (if there is one)</I>
<LI><A HREF="EST_TokenStream.html#filepos">filepos</A> <I>current file position in <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A></I>
<LI><A HREF="EST_TokenStream.html#linenum">linenum</A> <I>returns line number of <!1><A HREF="EST_TokenStream.html">EST_TokenStream</A></I>
<LI><B>operator >>:</B>
<UL>
<LI><A HREF="EST_TokenStream.html#operator >>">operator >></A>
<LI><A HREF="EST_TokenStream.html#operator >>">operator >></A>
</UL>
<LI><A HREF="EST_TokenStream.html#pos_description">pos_description</A> <I>A string describing current position, suitable for error messages</I>
<LI><A HREF="EST_TokenStream.html#restart">restart</A> <I>Reset to start of file/string </I>
<LI><A HREF="EST_TokenStream.html#seek">seek</A> <I>seek, reposition file pointer</I>
<LI><A HREF="EST_TokenStream.html#tell">tell</A> <I>tell, synonym for filepos</I>
<LI><A HREF="EST_TokenStream.html#fread">fread</A> <I>Reading binary data, (don't use peek() immediately beforehand)</I>
<LI><B>get:</B>
<UL>
<LI><A HREF="EST_TokenStream.html#get">get</A> <I>get next token in stream</I>
<LI><A HREF="EST_TokenStream.html#get">get</A> <I>get next token in stream</I>
</UL>
<LI><A HREF="EST_TokenStream.html#get_upto">get_upto</A> <I>get up to <TT>s</TT> in stream as a single token</I>
<LI><A HREF="EST_TokenStream.html#get_upto_eoln">get_upto_eoln</A> <I>get up to <TT>s</TT> in end of line as a single token</I>
<LI><A HREF="EST_TokenStream.html#peek">peek</A> <I>peek at next token</I>
<LI><A HREF="EST_TokenStream.html#quoted_mode">quoted_mode</A> <I>query quote mode</I>
<LI><A HREF="EST_TokenStream.html#set_PrePunctuationSymbols">set_PrePunctuationSymbols</A> <I>set which characters are to be treated as (post) punctuation</I>
<LI><A HREF="EST_TokenStream.html#set_PunctuationSymbols">set_PunctuationSymbols</A> <I>set which characters are to be treated as (post) punctuation</I>
<LI><A HREF="EST_TokenStream.html#set_SingleCharSymbols">set_SingleCharSymbols</A> <I>set which characters are to be treated as single character symbols</I>
<LI><A HREF="EST_TokenStream.html#set_WhiteSpaceChars">set_WhiteSpaceChars</A> <I>set which characters are to be treated as whitespace</I>
<LI><A HREF="EST_TokenStream.html#set_quotes">set_quotes</A> <I>set characters to be used as quotes and escape, and set quote mode</I>
<LI><A HREF="EST_TokenStream.html#~EST_TokenStream">EST_TokenStream::~EST_TokenStream</A> <I>will close file if appropriate for type</I>
<LI><B>a:</B>
<UL>
<LI><A HREF="EST_Track.html#a">a</A> <I>return amplitude of frame i, channel c</I>
<LI><A HREF="EST_Track.html#a">a</A> <I>return amplitude of point i, in the channel named name plus offset.</I>
<LI><A HREF="EST_Track.html#a">a</A> <I>return amplitude of time t, channel c.</I>
</UL>
<LI><A HREF="EST_Track.html#a_no_check">a_no_check</A> <I>return amplitude of frame i, channel c with no bounds checking.</I>
<LI><B>operator() :</B>
<UL>
<LI><A HREF="EST_Track.html#operator() ">operator() </A> <I>return amplitude of frame i, channel c.</I>
<LI><A HREF="EST_Track.html#operator() ">operator() </A> <I>return amplitude of frame i, channel 0.</I>
<LI><A HREF="EST_Track.html#operator() ">operator() </A> <I>return amplitude of frame nearest time t, channel c.</I>
<LI><A HREF="EST_Track.html#operator() ">operator() </A> <I>return amplitude of frame nearest time t, channel 0.</I>
</UL>
<LI><B>channel_position:</B>
<UL>
<LI><A HREF="EST_Track.html#channel_position">channel_position</A> <I>Return the position of channel <TT>name</TT> if it exists, otherwise return -1</I>
<LI><A HREF="EST_Track.html#channel_position">channel_position</A> <I>Return the position of channel <TT>name</TT> if it exists, otherwise return -1</I>
</UL>
<LI><B>has_channel:</B>
<UL>
<LI><A HREF="EST_Track.html#has_channel">has_channel</A> <I>Returns true if the track has a channel named <TT>name</TT>, otherwise false</I>
<LI><A HREF="EST_Track.html#has_channel">has_channel</A> <I>Returns true if the track has a channel named <TT>name</TT>, otherwise false</I>
</UL>
<LI><A HREF="EST_Track.html#copy_setup">copy_setup</A> <I>copy everything but data</I>
<LI><B>resize:</B>
<UL>
<LI><A HREF="EST_Track.html#resize">resize</A> <I>resize the track to have <TT>num_frames</TT> and <TT>num_channels</TT>.</I>
<LI><A HREF="EST_Track.html#resize">resize</A> <I>resize the track to have <TT>num_frames</TT> and <TT>num_channels</TT>.</I>
</UL>
<LI><A HREF="EST_Track.html#resize_aux">resize_aux</A> <I>resize the track's auxiliary channels</I>
<LI><A HREF="EST_Track.html#set_aux_channel_name">set_aux_channel_name</A> <I>set the name of the auxiliary channel</I>
<LI><A HREF="EST_Track.html#set_channel_name">set_channel_name</A> <I>set the name of the channel</I>
<LI><A HREF="EST_Track.html#set_num_channels">set_num_channels</A> <I>Change the number of channels while keeping the number of frames the same.</I>
<LI><A HREF="EST_Track.html#set_num_frames">set_num_frames</A> <I>Change the number of frames while keeping the number of channels the same.</I>
<LI><B>EST_Track:</B>
<UL>
<LI><A HREF="EST_Track.html#EST_Track">EST_Track</A> <I>Default constructor</I>
<LI><A HREF="EST_Track.html#EST_Track">EST_Track</A> <I>Copy constructor</I>
<LI><A HREF="EST_Track.html#EST_Track">EST_Track</A> <I>resizing constructor</I>
<LI><A HREF="EST_Track.html#EST_Track">EST_Track</A> <I>resizing constructor</I>
</UL>
<LI><A HREF="EST_Track.html#~EST_Track">~EST_Track</A> <I>default destructor</I>
<LI><B>load:</B>
<UL>
<LI><A HREF="EST_Track.html#load">load</A> <I>Load a file called <TT>name</TT> of format <TT>type</TT> into the track.</I>
<LI><A HREF="EST_Track.html#load">load</A> <I>Load character data from an already opened tokenstream <TT>ts</TT> into the track.</I>
<LI><A HREF="EST_Track.html#load">load</A> <I>Load a file called <TT>name</TT> into the track.</I>
</UL>
<LI><B>save:</B>
<UL>
<LI><A HREF="EST_Track.html#save">save</A> <I>Save the track to a file <TT>name</TT> of format <TT>type</TT>.</I>
<LI><A HREF="EST_Track.html#save">save</A> <I>Save the track to a already opened file pointer<TT>FP</TT> and write a file of format <TT>type</TT>.</I>
</UL>
<LI><B>channel:</B>
<UL>
<LI><A HREF="EST_Track.html#channel">channel</A> <I>make <TT>fv</TT> a window to channel <TT>n</TT> in the track.</I>
<LI><A HREF="EST_Track.html#channel">channel</A> <I>make <TT>fv</TT> a window to the named channel in the track.</I>
</UL>
<LI><B>copy_channel_in:</B>
<UL>
<LI><A HREF="EST_Track.html#copy_channel_in">copy_channel_in</A> <I>copy buf into pre-allocated channel n of track </I>
<LI><A HREF="EST_Track.html#copy_channel_in">copy_channel_in</A> <I>copy channel buf into pre-allocated channel n of track </I>
</UL>
<LI><A HREF="EST_Track.html#copy_channel_out">copy_channel_out</A> <I>copy channel <TT>n</TT> into pre-allocated buffer buf </I>
<LI><B>copy_frame_in:</B>
<UL>
<LI><A HREF="EST_Track.html#copy_frame_in">copy_frame_in</A> <I>copy from into frame n of track </I>
<LI><A HREF="EST_Track.html#copy_frame_in">copy_frame_in</A> <I>copy t into frame n of track </I>
<LI><A HREF="EST_Track.html#copy_frame_in">copy_frame_in</A> <I>copy buf into frame n of track </I>
</UL>
<LI><B>copy_frame_out:</B>
<UL>
<LI><A HREF="EST_Track.html#copy_frame_out">copy_frame_out</A> <I>copy frame <TT>n</TT> into pre-allocated buffer buf </I>
<LI><A HREF="EST_Track.html#copy_frame_out">copy_frame_out</A> <I>copy frame <TT>n</TT> into EST_FVector </I>
</UL>
<LI><A HREF="EST_Track.html#copy_sub_track">copy_sub_track</A> <I>Copy contiguous portion of track into <TT>st</TT>.</I>
<LI><A HREF="EST_Track.html#frame">frame</A> <I>make <TT>fv</TT> a window to frame <TT>n</TT> in the track.</I>
<LI><B>sub_track:</B>
<UL>
<LI><A HREF="EST_Track.html#sub_track">sub_track</A> <I>make <TT>st</TT> refer to a portion of the track.</I>
<LI><A HREF="EST_Track.html#sub_track">sub_track</A> <I>make <TT>st</TT> refer to a portion of the track.</I>
<LI><A HREF="EST_Track.html#sub_track">sub_track</A> <I>make <TT>st</TT> refer to a portion of the track.make <TT>st</TT> refer to a portion of the track.</I>
</UL>
<LI><A HREF="EST_Track.html#name">name</A> <I>name of track - redundant use access to features</I>
<LI><A HREF="EST_Track.html#set_name">set_name</A> <I>set name of track - redundant use access to features</I>
<LI><A HREF="EST_Track.html#change_type">change_type</A> <I>REDO</I>
<LI><A HREF="EST_Track.html#end">end</A> <I>return time of last value in track</I>
<LI><A HREF="EST_Track.html#fill">fill</A> <I>fill all amplitudes with value <TT>v</TT> </I>
<LI><B>fill_time:</B>
<UL>
<LI><A HREF="EST_Track.html#fill_time">fill_time</A> <I>set frame times to regular intervals of time <TT>t</TT></I>
<LI><A HREF="EST_Track.html#fill_time">fill_time</A> <I>fill times with times of other track</I>
</UL>
<LI><A HREF="EST_Track.html#ms_t">ms_t</A> <I>return time of framet i in milli-seconds</I>
<LI><A HREF="EST_Track.html#sample">sample</A> <I>resample track at this frame shift, specified in seconds.</I>
<LI><A HREF="EST_Track.html#shift">shift</A> <I>return an estimation of the frame spacing in seconds.</I>
<LI><A HREF="EST_Track.html#start">start</A> <I>return time of first value in track</I>
<LI><A HREF="EST_Track.html#t">t</A> <I>return time position of frame i</I>
<LI><A HREF="EST_Track.html#empty">empty</A> <I>returns true if no values are set in the frame </I>
<LI><A HREF="EST_Track.html#equal_space">equal_space</A> <I>return true if track has equal (ie.</I>
<LI><A HREF="EST_Track.html#index">index</A> <I>return the frame index nearest time t</I>
<LI><A HREF="EST_Track.html#index_below">index_below</A> <I>return the frame index before time t</I>
<LI><A HREF="EST_Track.html#length">length</A> <I>return number of frames in track</I>
<LI><A HREF="EST_Track.html#next_non_break">next_non_break</A> <I>starting at frame i, return the frame index of the first value frame after i.</I>
<LI><A HREF="EST_Track.html#num_aux_channels">num_aux_channels</A> <I>return number of auxiliary channels in track</I>
<LI><A HREF="EST_Track.html#num_channels">num_channels</A> <I>return number of channels in track</I>
<LI><A HREF="EST_Track.html#num_frames">num_frames</A> <I>return number of frames in track</I>
<LI><A HREF="EST_Track.html#prev_non_break">prev_non_break</A> <I>starting at frame i, return the frame index of the first value frame before i.</I>
<LI><A HREF="EST_Track.html#rm_excess_breaks">rm_excess_breaks</A> <I>If the contour has multiple break values between sections containing values, reduce the break sections so that each has a single break only.</I>
<LI><A HREF="EST_Track.html#set_break">set_break</A> <I>set frame i to be a break</I>
<LI><A HREF="EST_Track.html#set_value">set_value</A> <I>set frame i to be a value</I>
<LI><A HREF="EST_Track.html#single_break">single_break</A> <I>return true if track has only single breaks between value sections </I>
<LI><A HREF="EST_Track.html#track_break">track_break</A> <I>return true if frame i is a break</I>
<LI><A HREF="EST_Track.html#val">val</A> <I>return true if frame i is a value</I>
<LI><B>EST_TrackMap:</B>
<UL>
<LI><A HREF="EST_TrackMap.html#EST_TrackMap">EST_TrackMap::EST_TrackMap</A> <I>No copy constructor.</I>
<LI><A HREF="EST_TrackMap.html#EST_TrackMap">EST_TrackMap::EST_TrackMap</A> <I>Creation function used by friends to create refcounted maps</I>
<LI><A HREF="EST_TrackMap.html#EST_TrackMap">EST_TrackMap::EST_TrackMap</A> <I>Creation function used by friends to create sub-trak maps</I>
<LI><A HREF="EST_TrackMap.html#EST_TrackMap">EST_TrackMap::EST_TrackMap</A> <I>Default constructor</I>
<LI><A HREF="EST_TrackMap.html#EST_TrackMap">EST_TrackMap::EST_TrackMap</A> <I>Copy the mapping</I>
<LI><A HREF="EST_TrackMap.html#EST_TrackMap">EST_TrackMap::EST_TrackMap</A> <I>Create from static table</I>
</UL>
<LI><A HREF="EST_TrackMap.html#channel_type">EST_TrackMap::channel_type</A> <I>Returns the type of the channel at the given position</I>
<LI><A HREF="EST_TrackMap.html#clear">EST_TrackMap::clear</A> <I>Empty the map</I>
<LI><A HREF="EST_TrackMap.html#copy">EST_TrackMap::copy</A> <I>copy an exiting map</I>
<LI><A HREF="EST_TrackMap.html#get">EST_TrackMap::get</A> <I>Get the position of a channel</I>
<LI><A HREF="EST_TrackMap.html#has_channel">EST_TrackMap::has_channel</A> <I>Does the mapping contain a position for this channel?</I>
<LI><A HREF="EST_TrackMap.html#init">EST_TrackMap::init</A> <I>Initialise the map</I>
<LI><A HREF="EST_TrackMap.html#last_channel">EST_TrackMap::last_channel</A> <I>Returns the index of the last known channel</I>
<LI><A HREF="EST_TrackMap.html#operator() ">EST_TrackMap::operator() </A> <I>Get the position of a channel</I>
<LI><A HREF="EST_TrackMap.html#set">EST_TrackMap::set</A> <I>Record the position of a channel</I>
<LI><B>EST_TrieNode:</B>
<UL>
<LI><A HREF="EST_TrieNode.html#EST_TrieNode">EST_TrieNode::EST_TrieNode</A>
<LI><A HREF="EST_TrieNode.html#EST_TrieNode">EST_TrieNode::EST_TrieNode</A>
</UL>
<LI><A HREF="EST_TrieNode.html#add">EST_TrieNode::add</A> <I>add <TT>item</TT> for <TT>key</TT> overwriting previous contents</I>
<LI><A HREF="EST_TrieNode.html#copy_into">EST_TrieNode::copy_into</A> <I>copy all entries in trie node into trie</I>
<LI><A HREF="EST_TrieNode.html#lookup">EST_TrieNode::lookup</A> <I>Find the contents for given string, 0 if no current contents</I>
<LI><A HREF="EST_TrieNode.html#~EST_TrieNode">EST_TrieNode::~EST_TrieNode</A>
<LI><A HREF="EST_Utterance.html#EST_Utterance">EST_Utterance</A> <I>default constructor</I>
<LI><B>load:</B>
<UL>
<LI><A HREF="EST_Utterance.html#load">load</A> <I>load an utterance from an ascii file</I>
<LI><A HREF="EST_Utterance.html#load">load</A> <I>load an utterance from a already opened token stream</I>
</UL>
<LI><B>save:</B>
<UL>
<LI><A HREF="EST_Utterance.html#save">save</A> <I>save an utterance to an ostream</I>
<LI><A HREF="EST_Utterance.html#save">save</A> <I>save an utterance to an ascii file</I>
</UL>
<LI><A HREF="EST_Utterance.html#clear">clear</A> <I>remove everything in utterance</I>
<LI><A HREF="EST_Utterance.html#clear_relations">clear_relations</A> <I>clear the contents of the relations only</I>
<LI><A HREF="EST_Utterance.html#init">init</A> <I>initialise utterance</I>
<LI><A HREF="EST_Utterance.html#next_id">next_id</A> <I>return the id of the next item</I>
<LI><A HREF="EST_Utterance.html#set_highest_id">set_highest_id</A> <I>set the next id to be <parameter>n</parameter></I>
<LI><A HREF="EST_Utterance.html#create_relation">create_relation</A> <I>create a new relation called <parameter>n</parameter></I>
<LI><A HREF="EST_Utterance.html#evaluate_all_features">evaluate_all_features</A> <I>Evaluarte all feature functions in utterance</I>
<LI><A HREF="EST_Utterance.html#id">id</A> <I>return EST_Item whose id is <parameter>n</parameter></I>
<LI><A HREF="EST_Utterance.html#num_relations">num_relations</A> <I>number of relations in this utterance</I>
<LI><A HREF="EST_Utterance.html#relation">relation</A> <I>get relation by name</I>
<LI><B>relation_present:</B>
<UL>
<LI><A HREF="EST_Utterance.html#relation_present">relation_present</A> <I>returns true if utterance contains named relations.</I>
<LI><A HREF="EST_Utterance.html#relation_present">relation_present</A> <I>returns true if utterance contains all the relations named in the list <B>name</B>.</I>
</UL>
<LI><A HREF="EST_Utterance.html#remove_relation">remove_relation</A> <I>remove the relation called <parameter>n</parameter></I>
<LI><B>EST_Val:</B>
<UL>
<LI><A HREF="EST_Val.html#EST_Val">EST_Val</A> <I>Default constructor </I>
<LI><A HREF="EST_Val.html#EST_Val">EST_Val</A> <I>Copy constructor for another EST_Val</I>
<LI><A HREF="EST_Val.html#EST_Val">EST_Val</A> <I>Copy constructor for an int</I>
<LI><A HREF="EST_Val.html#EST_Val">EST_Val</A> <I>Copy constructor for a float</I>
<LI><A HREF="EST_Val.html#EST_Val">EST_Val</A> <I>Copy constructor for a double</I>
<LI><A HREF="EST_Val.html#EST_Val">EST_Val</A> <I>Copy constructor for a string</I>
<LI><A HREF="EST_Val.html#EST_Val">EST_Val</A> <I>Copy constructor for a string literal</I>
</UL>
<LI><A HREF="EST_Val.html#~EST_Val">~EST_Val</A> <I>Destructor </I>
<LI><A HREF="EST_Val.html#operator EST_String">operator EST_String</A> <I>Automatically cast val as an string</I>
<LI><A HREF="EST_Val.html#operator float">operator float</A> <I>Automatically cast val as an float</I>
<LI><A HREF="EST_Val.html#operator int">operator int</A> <I>Automatically cast val as an int</I>
<LI><A HREF="EST_Val.html#if">if</A>
<LI><B>operator !=:</B>
<UL>
<LI><A HREF="EST_Val.html#operator !=">operator !=</A> <I>Test whether val is not equal to the val a</I>
<LI><A HREF="EST_Val.html#operator !=">operator !=</A> <I>Test whether val is not equal to the string a</I>
<LI><A HREF="EST_Val.html#operator !=">operator !=</A> <I>Test whether val is not equal to the char * a</I>
<LI><A HREF="EST_Val.html#operator !=">operator !=</A> <I>Test whether val is not equal to the int a</I>
<LI><A HREF="EST_Val.html#operator !=">operator !=</A> <I>Test whether val is not equal to the float a</I>
<LI><A HREF="EST_Val.html#operator !=">operator !=</A> <I>Test whether val is not equal to the double float a</I>
</UL>
<LI><B>operator ==:</B>
<UL>
<LI><A HREF="EST_Val.html#operator ==">operator ==</A> <I>Test whether val is equal to the string a</I>
<LI><A HREF="EST_Val.html#operator ==">operator ==</A> <I>Test whether val is equal to a</I>
<LI><A HREF="EST_Val.html#operator ==">operator ==</A> <I>Test whether val is equal to the double a</I>
<LI><A HREF="EST_Val.html#operator ==">operator ==</A> <I>Test whether val is equal to the char * a</I>
<LI><A HREF="EST_Val.html#operator ==">operator ==</A> <I>Test whether val is equal to the int a</I>
<LI><A HREF="EST_Val.html#operator ==">operator ==</A> <I>Test whether val is equal to the float a</I>
</UL>
<LI><A HREF="EST_Val.html#F">F</A> <I>returns the value, cast as an float </I>
<LI><A HREF="EST_Val.html#Float">Float</A> <I>returns the value, cast as an float </I>
<LI><A HREF="EST_Val.html#I">I</A> <I>returns the value, cast as an int </I>
<LI><A HREF="EST_Val.html#Int">Int</A> <I>returns the value, cast as an int </I>
<LI><A HREF="EST_Val.html#S">S</A> <I>returns the value, cast as an string </I>
<LI><A HREF="EST_Val.html#String">String</A> <I>returns the value, cast as an string </I>
<LI><A HREF="EST_Val.html#string">string</A> <I>returns the value, cast as an string </I>
<LI><A HREF="EST_Val.html#string_only">string_only</A> <I>returns the value, cast as an string </I>
<LI><A HREF="EST_Val.html#type">type</A> <I>returns the type that the val is currently holding </I>
<LI><B>operator=:</B>
<UL>
<LI><A HREF="EST_Val.html#operator=">operator=</A> <I>Assignment of val to another val</I>
<LI><A HREF="EST_Val.html#operator=">operator=</A> <I>Assignment of val to an int </I>
<LI><A HREF="EST_Val.html#operator=">operator=</A> <I>Assignment of val to a float </I>
<LI><A HREF="EST_Val.html#operator=">operator=</A> <I>Assignment of val to a double </I>
<LI><A HREF="EST_Val.html#operator=">operator=</A> <I>Assignment of val to a string </I>
<LI><A HREF="EST_Val.html#operator=">operator=</A> <I>Assignment of val to a string literal</I>
</UL>
<LI><B>EST_Viterbi_Decoder:</B>
<UL>
<LI><A HREF="EST_Viterbi_Decoder.html#EST_Viterbi_Decoder">EST_Viterbi_Decoder::EST_Viterbi_Decoder</A> <I>Construct a decoder with given candidate function and join function with a state size as specified</I>
<LI><A HREF="EST_Viterbi_Decoder.html#EST_Viterbi_Decoder">EST_Viterbi_Decoder::EST_Viterbi_Decoder</A> <I>Construct a decoder with given candidate function and join function, as number of states is given this implies a beam search</I>
</UL>
<LI><A HREF="EST_Viterbi_Decoder.html#add_cand_prune">EST_Viterbi_Decoder::add_cand_prune</A> <I>Add a new candidtate to list if better than others, pruning the list if required</I>
<LI><A HREF="EST_Viterbi_Decoder.html#copy_feature">EST_Viterbi_Decoder::copy_feature</A> <I>Copy named feature from the best path to related stream item</I>
<LI><A HREF="EST_Viterbi_Decoder.html#initialise">EST_Viterbi_Decoder::initialise</A> <I>Build the initial table from a <!1><A HREF="EST_Relation.html">EST_Relation</A></I>
<LI><A HREF="EST_Viterbi_Decoder.html#result">EST_Viterbi_Decoder::result</A> <I>Extract the result from the table and store it as a feature on the related <!1><A HREF="EST_Item.html">EST_Item</A> in the given <!1><A HREF="EST_Relation.html">EST_Relation</A> named as <TT>n</TT>.</I>
<LI><A HREF="EST_Viterbi_Decoder.html#search">EST_Viterbi_Decoder::search</A> <I>Do the the actual search</I>
<LI><A HREF="EST_Viterbi_Decoder.html#set_beam_width">EST_Viterbi_Decoder::set_beam_width</A> <I>Only for use in beam search mode: number of paths to consider</I>
<LI><A HREF="EST_Viterbi_Decoder.html#set_big_is_good">EST_Viterbi_Decoder::set_big_is_good</A> <I>Define is good scores are bigger or smaller.</I>
<LI><A HREF="EST_Viterbi_Decoder.html#set_cand_width">EST_Viterbi_Decoder::set_cand_width</A> <I>Only for use in beam search mode: number of condidates to consider</I>
<LI><A HREF="EST_Viterbi_Decoder.html#set_debug">EST_Viterbi_Decoder::set_debug</A> <I>Output some debugging information</I>
<LI><A HREF="EST_Viterbi_Decoder.html#set_pruning_parameters">EST_Viterbi_Decoder::set_pruning_parameters</A> <I>set beam widths for pruning</I>
<LI><A HREF="EST_Viterbi_Decoder.html#~EST_Viterbi_Decoder">EST_Viterbi_Decoder::~EST_Viterbi_Decoder</A>
<LI><A HREF="EST_WFST.html#complement">complement</A> <I>Build complement of a</I>
<LI><A HREF="EST_WFST.html#compose">compose</A> <I>Build new WFST by composition of a and b.</I>
<LI><A HREF="EST_WFST.html#concat">concat</A> <I>Build WFST that accepts a language that consists of any string in a followed by any string in b *</I>
<LI><A HREF="EST_WFST.html#determinize">determinize</A> <I>Build determinized form of a</I>
<LI><A HREF="EST_WFST.html#difference">difference</A> <I>Build WFST that accepts only strings in a that aren't also accepted by strings in b.</I>
<LI><B>intersection:</B>
<UL>
<LI><A HREF="EST_WFST.html#intersection">intersection</A> <I>Build intersection of WFSTs a and b The new WFST recognizes the only the strings that are recognized by both a and b list </I>
<LI><A HREF="EST_WFST.html#intersection">intersection</A> <I>Build intersection of all WFSTs in given list.</I>
</UL>
<LI><A HREF="EST_WFST.html#minimize">minimize</A> <I>Build minimized form of a</I>
<LI><B>uunion:</B>
<UL>
<LI><A HREF="EST_WFST.html#uunion">uunion</A> <I>Build union of WFSTs a and b.</I>
<LI><A HREF="EST_WFST.html#uunion">uunion</A> <I>Build union of all WFSTs in given list.</I>
</UL>
<LI><A HREF="EST_WFST.html#cumulate">cumulate</A> <I>Cumulation condition</I>
<LI><A HREF="EST_WFST.html#start_cumulate">start_cumulate</A> <I>Clear and start cumulation</I>
<LI><A HREF="EST_WFST.html#stop_cumulate">stop_cumulate</A> <I>Stop cumulation and calculate probabilities on transitions</I>
<LI><A HREF="EST_WFST.html#epsilon_label">epsilon_label</A> <I>LISP for on epsilon symbols</I>
<LI><A HREF="EST_WFST.html#final">final</A> <I>True if state <TT>i</TT> is final</I>
<LI><A HREF="EST_WFST.html#in_epsilon">in_epsilon</A> <I>Internal index for input epsilon</I>
<LI><B>in_symbol:</B>
<UL>
<LI><A HREF="EST_WFST.html#in_symbol">in_symbol</A> <I>Map input alphabet index to input symbol</I>
<LI><A HREF="EST_WFST.html#in_symbol">in_symbol</A> <I>Map input symbol to input alphabet index</I>
</UL>
<LI><A HREF="EST_WFST.html#out_epsilon">out_epsilon</A> <I>Internal index for output epsilon</I>
<LI><B>out_symbol:</B>
<UL>
<LI><A HREF="EST_WFST.html#out_symbol">out_symbol</A> <I>Map output alphabet index to output symbol </I>
<LI><A HREF="EST_WFST.html#out_symbol">out_symbol</A> <I>Map output symbol to output alphabet index</I>
</UL>
<LI><A HREF="EST_WFST.html#state">state</A> <I>Return internal state information</I>
<LI><A HREF="EST_WFST.html#clear">clear</A> <I>clear removing existing states if any</I>
<LI><A HREF="EST_WFST.html#copy">copy</A> <I>Copy from existing wfst</I>
<LI><B>init:</B>
<UL>
<LI><A HREF="EST_WFST.html#init">init</A> <I>clear an initialise with given input and out alphabets</I>
<LI><A HREF="EST_WFST.html#init">init</A> <I>Clear with (estimation of number of states required)</I>
</UL>
<LI><A HREF="EST_WFST.html#add_state">add_state</A> <I>Add a new state, returns new name</I>
<LI><A HREF="EST_WFST.html#build_and_transition">build_and_transition</A> <I>Basic conjunction constructor</I>
<LI><A HREF="EST_WFST.html#build_or_transition">build_or_transition</A> <I>Basic disjunction constructor</I>
<LI><A HREF="EST_WFST.html#build_wfst">build_wfst</A> <I>Basic regex constructor</I>
<LI><A HREF="EST_WFST.html#ms_type">ms_type</A> <I>Given a multi-state return type (final, ok, error)</I>
<LI><A HREF="EST_WFST.html#add_epsilon_reachable">add_epsilon_reachable</A> <I>Extend multi-state with epsilon reachable states</I>
<LI><A HREF="EST_WFST.html#apply_multistate">apply_multistate</A> <I>Transduce a multi-state given n and out</I>
<LI><A HREF="EST_WFST.html#deterministic">deterministic</A> <I>True if WFST is deterministic</I>
<LI><A HREF="EST_WFST.html#operator = ">operator = </A>
<LI><A HREF="EST_WFST.html#remove_error_states">remove_error_states</A> <I>Remove error states from the WFST</I>
<LI><A HREF="EST_WFST.html#find_transition">find_transition</A> <I>Find (first) transition given in and out symbols</I>
<LI><B>transduce:</B>
<UL>
<LI><A HREF="EST_WFST.html#transduce">transduce</A> <I>Transduce in to out (strings) from state</I>
<LI><A HREF="EST_WFST.html#transduce">transduce</A> <I>Transduce in to list of transitions</I>
<LI><A HREF="EST_WFST.html#transduce">transduce</A> <I>Transduce in to out from state</I>
</UL>
<LI><B>transition:</B>
<UL>
<LI><A HREF="EST_WFST.html#transition">transition</A> <I>Find (first) new state given in/out string</I>
<LI><A HREF="EST_WFST.html#transition">transition</A> <I>Find (first) new state given in and out symbols</I>
<LI><A HREF="EST_WFST.html#transition">transition</A> <I>Find (first) new state given in and out strings</I>
</UL>
<LI><A HREF="EST_WFST.html#transition_all">transition_all</A> <I>Find all possible transitions for given state/input/output</I>
<LI><A HREF="EST_Wave.html#a">a</A> <I>return amplitude of sample <tt>i</tt> from channel <tt> channel</tt>.</I>
<LI><A HREF="EST_Wave.html#a_safe">a_safe</A> <I>Version of a() that returns zero if index is out of array bounds.</I>
<LI><B>operator():</B>
<UL>
<LI><A HREF="EST_Wave.html#operator()">operator()</A> <I>return amplitude of sample <tt>i</tt> from channel <tt> channel</tt>.</I>
<LI><A HREF="EST_Wave.html#operator()">operator()</A> <I>return amplitude of sample <tt>i</tt> from channel 0.</I>
</UL>
<LI><A HREF="EST_Wave.html#t">t</A> <I>return the time position in seconds of the ith sample</I>
<LI><B>EST_Wave:</B>
<UL>
<LI><A HREF="EST_Wave.html#EST_Wave">EST_Wave::EST_Wave</A> <I>Construct from memory supplied by caller</I>
<LI><A HREF="EST_Wave.html#EST_Wave">EST_Wave::EST_Wave</A> <I>default constructor</I>
<LI><A HREF="EST_Wave.html#EST_Wave">EST_Wave::EST_Wave</A> <I>copy constructor</I>
</UL>
<LI><A HREF="EST_Wave.html#load">load</A> <I>Load a file into the waveform.</I>
<LI><A HREF="EST_Wave.html#load_file">load_file</A> <I>Load a file of type <tt>filetype</tt> into the waveform.</I>
<LI><A HREF="EST_Wave.html#end">end</A> <I>return the time position of the last sample</I>
<LI><A HREF="EST_Wave.html#have_left_context">have_left_context</A> <I>Can we look N samples to the left?</I>
<LI><A HREF="EST_Wave.html#length">length</A> <I>return the size of the waveform, ie.</I>
<LI><A HREF="EST_Wave.html#name">name</A> <I>A string indentifying the waveform, commonly used to store the filename</I>
<LI><A HREF="EST_Wave.html#num_channels">num_channels</A> <I>return the number of channels in the waveform</I>
<LI><A HREF="EST_Wave.html#num_samples">num_samples</A> <I>return the number of samples in the waveform</I>
<LI><A HREF="EST_Wave.html#sample_rate">sample_rate</A> <I>return the sampling rate (frequency)</I>
<LI><A HREF="EST_Wave.html#sample_type">sample_type</A> <I>returns the file format of the file from which the waveform was read.</I>
<LI><A HREF="EST_Wave.html#set_name">set_name</A> <I>Sets name</I>
<LI><A HREF="EST_Wave.html#set_sample_rate">set_sample_rate</A> <I>Set sampling rate to <tt>n</tt></I>
<LI><A HREF="EST_Wave.html#clear">clear</A> <I>clear waveform and set size to 0</I>
<LI><A HREF="EST_Wave.html#resample">resample</A> <I>Resample waveform to <tt>rate</tt></I>
<LI><A HREF="EST_Wave.html#rescale">rescale</A> <I>multiply all samples by a factor <tt>gain</tt>.</I>
<LI><A HREF="EST_Wave.html#resize">resize</A> <I>resize the waveform </I>
<LI><A HREF="EST_Wave.html#integrity">EST_Wave::integrity</A>
<LI><A HREF="EST_Wave.html#operator +=">EST_Wave::operator +=</A> <I>Add to existing wave in serial.</I>
<LI><A HREF="EST_Wave.html#operator = ">EST_Wave::operator = </A> <I>Assignment operator</I>
<LI><A HREF="EST_Wave.html#operator |=">EST_Wave::operator |=</A> <I>Add wave in parallel, ie.</I>
<LI><A HREF="EST_Window.html#creator">creator</A> <I>Return the creation function for the given window type</I>
<LI><B>make_window:</B>
<UL>
<LI><A HREF="EST_Window.html#make_window">make_window</A> <I>Make a Buffer of containing a window function of specified type.</I>
<LI><A HREF="EST_Window.html#make_window">make_window</A> <I>Make a EST_FVector containing a window function of specified type.</I>
</UL>
<LI><B>window_signal:</B>
<UL>
<LI><A HREF="EST_Window.html#window_signal">window_signal</A> <I>Window the waveform <TT>sig</TT> starting at point <TT>start</TT> for a duration of <TT>size</TT> samples.</I>
<LI><A HREF="EST_Window.html#window_signal">window_signal</A> <I>Window the waveform <TT>sig</TT> starting at point <TT>start</TT> for a duration of <TT>size</TT> samples.</I>
<LI><A HREF="EST_Window.html#window_signal">window_signal</A> <I>Window the waveform <TT>sig</TT> starting at point <TT>start</TT> for a duration of <TT>size</TT> samples.</I>
<LI><A HREF="EST_Window.html#window_signal">window_signal</A> <I>Window the waveform <TT>sig</TT> starting at point <TT>start</TT> for a duration of <TT>size</TT> samples.</I>
</UL>
<LI><A HREF="EST_Window.html#description">description</A> <I>Return the description for a given window type</I>
<LI><A HREF="EST_Window.html#options_short">options_short</A> <I>Return a comma separated list of the available window types</I>
<LI><A HREF="EST_Window.html#options_supported">options_supported</A> <I>Return a paragraph describing the available windows</I>
<LI><B>EST_bracketed_string:</B>
<UL>
<LI><A HREF="EST_bracketed_string.html#EST_bracketed_string">EST_bracketed_string::EST_bracketed_string</A>
<LI><A HREF="EST_bracketed_string.html#EST_bracketed_string">EST_bracketed_string::EST_bracketed_string</A>
</UL>
<LI><A HREF="EST_bracketed_string.html#length">EST_bracketed_string::length</A>
<LI><A HREF="EST_bracketed_string.html#operator !=">EST_bracketed_string::operator !=</A>
<LI><A HREF="EST_bracketed_string.html#set_bracketed_string">EST_bracketed_string::set_bracketed_string</A>
<LI><A HREF="EST_bracketed_string.html#string">EST_bracketed_string::string</A>
<LI><A HREF="EST_bracketed_string.html#symbol_at">EST_bracketed_string::symbol_at</A> <I>The nth symbol in the string</I>
<LI><A HREF="EST_bracketed_string.html#valid">EST_bracketed_string::valid</A> <I>If a bracketing from i to k is valid in string</I>
<LI><A HREF="EST_bracketed_string.html#~EST_bracketed_string">EST_bracketed_string::~EST_bracketed_string</A>
<LI><A HREF="absval.4.html">absval</A> <I>Absolute value</I>
<LI><A HREF="absval.html">absval</A> <I>Absolute value</I>
<LI><A HREF="absval.2.html">absval</A> <I>Absolute value</I>
<LI><A HREF="absval.3.html">absval</A> <I>Absolute value</I>
<LI><A HREF="iceil.html">iceil</A> <I>Round up</I>
<LI><A HREF="ifloor.html">ifloor</A> <I>Round down</I>
<LI><A HREF="irint.2.html">irint</A> <I>Round to nearest integer</I>
<LI><A HREF="irint.html">irint</A> <I>Round to nearest integer</I>
<LI><A HREF="max.3.html">max</A> <I>Larger of two doubles</I>
<LI><A HREF="max.html">max</A> <I>Larger of two ints</I>
<LI><A HREF="max.2.html">max</A> <I>Larger of two floats</I>
<LI><A HREF="min.3.html">min</A> <I>Smaller of two doubles</I>
<LI><A HREF="min.html">min</A> <I>Smaller of two ints</I>
<LI><A HREF="min.2.html">min</A> <I>Smaller of two floats</I>
<LI><A HREF="srint.2.html">srint</A> <I>Round to nearest integer</I>
<LI><A HREF="srint.html">srint</A> <I>Round to nearest integer</I>
<LI><A HREF="get_frame.2.html">get_frame</A> <I>Get the start and end of a given frame (in seconds)</I>
<LI><A HREF="get_frame.html">get_frame</A> <I>Get the start and end of a given frame (in samples)</I>
<LI><A HREF="get_frame_o.2.html">get_frame_o</A> <I>Get the start and end of a given frame (in seconds)</I>
<LI><A HREF="get_frame_o.html">get_frame_o</A> <I>Get the start and end of a given frame (in samples)</I>
<LI><A HREF="abs_error.html">abs_error</A> <I>Calculate the mean absolute error between the same channel in two tracks.</I>
<LI><A HREF="align_to_track.2.html">align_to_track</A> <I>Move the start and end variables to the nearest frame</I>
<LI><A HREF="align_to_track.html">align_to_track</A> <I>Move the start and end variables to the nearest frame</I>
<LI><A HREF="differentiate.html">differentiate</A> <I>Calculate the simple derivative of a track.</I>
<LI><A HREF="get_frame_size.html">get_frame_size</A> <I>Return the frame size in <B>samples</B> based on analysis of current time points.</I>
<LI><A HREF="get_order.html">get_order</A> <I>How many coefficiants in track (looks for Coef0 and coefN channels)</I>
<LI><A HREF="get_start_positions.html">get_start_positions</A> <I>Find the start point in the signal of the sections of speech related to each frame</I>
<LI><A HREF="get_time_frame_size.html">get_time_frame_size</A> <I>Return the frame size in <B>seconds</B> based on analysis of current time points.</I>
<LI><A HREF="move_start.html">move_start</A> <I>Move the track by <I>shift</I> seconds</I>
<LI><A HREF="move_to_frame_ends.html">move_to_frame_ends</A> <I>Move the start and end variables to the start and end of the nearest frame</I>
<LI><A HREF="nearest_boundary.html">nearest_boundary</A> <I>Index of the frame whose start boundary</I>
<LI><A HREF="rms_error.html">rms_error</A> <I>Calculate the root mean square error between the same channel in two tracks.</I>
<LI><A HREF="rms_error.2.html">rms_error</A> <I>Calculate the root mean square error between each channels in two tracks.</I>
<LI><A HREF="set_start.html">set_start</A> <I>Move the track so that it starts at the indicated time</I>
<LI><A HREF="sum_lengths.html">sum_lengths</A> <I>Total the length channel values</I>
<LI><A HREF="wave_combine_channels.html">wave_combine_channels</A> <I>extract lkj lkjf lkj.</I>
<LI><A HREF="wave_extract_channel.html">wave_extract_channel</A> <I>extract lkj lkjf lkj.</I>
<LI><A HREF="wave_subwave.html">wave_subwave</A> <I>extract lkj lkjf lkj.</I>
<LI><A HREF="E_step.html">E_step</A> <I>at last, some interesting functions</I>
<LI><A HREF="sig2pow.html">sig2pow</A> <I>Calculate the power for a frame of speech.</I>
<LI><A HREF="sig2rms.html">sig2rms</A> <I>Calculate the root mean square energy for a frame of speech.</I>
<LI><A HREF="FIR_double_filter.html">FIR_double_filter</A> <I>General purpose FIR double (zero-phase) filter.</I>
<LI><A HREF="FIRfilter.html">FIRfilter</A> <I>General purpose FIR filter.</I>
<LI><A HREF="FIRhighpass_double_filter.html">FIRhighpass_double_filter</A> <I>Quick function for one-off double low pass filtering.</I>
<LI><A HREF="FIRhighpass_double_filter.2.html">FIRhighpass_double_filter</A> <I>Quick function for one-off double low pass filtering.</I>
<LI><A HREF="FIRhighpass_filter.html">FIRhighpass_filter</A> <I>Quick function for one-off high pass filtering.</I>
<LI><A HREF="FIRhighpass_filter.2.html">FIRhighpass_filter</A> <I>Quick function for one-off high pass filtering.</I>
<LI><A HREF="FIRlowpass_double_filter.html">FIRlowpass_double_filter</A> <I>Quick function for one-off zero phase high pass filtering.</I>
<LI><A HREF="FIRlowpass_double_filter.2.html">FIRlowpass_double_filter</A> <I>Quick function for one-off zero phase high pass filtering.</I>
<LI><A HREF="FIRlowpass_filter.html">FIRlowpass_filter</A> <I>Quick function for one-off low pass filtering.</I>
<LI><A HREF="FIRlowpass_filter.2.html">FIRlowpass_filter</A> <I>Quick function for one-off low pass filtering.</I>
<LI><A HREF="FFT.html">FFT</A> <I>Alternate name for slowFFT</I>
<LI><A HREF="IFFT.html">IFFT</A> <I>Alternate name for slowIFFT</I>
<LI><A HREF="fastFFT.html">fastFFT</A> <I>Fast FFT An optimised implementation by Tony Robinson to be used in preference to slowFFT</I>
<LI><A HREF="power_spectrum.html">power_spectrum</A> <I>Power spectrum using the fastFFT function.</I>
<LI><A HREF="power_spectrum_slow.html">power_spectrum_slow</A> <I>Power spectrum using the slowFFT function</I>
<LI><A HREF="slowFFT.html">slowFFT</A> <I>Basic in-place FFT.</I>
<LI><A HREF="slowIFFT.html">slowIFFT</A> <I>Basic inverse in-place FFT int slowFFT</I>
<LI><A HREF="design_FIR_filter.html">design_FIR_filter</A> <I>Create an artibtrary filter or order <TT>order</TT> that attempts to give the frequecny response given by <TT>freq_response</TT>.</I>
<LI><A HREF="design_highpass_FIR_filter.html">design_highpass_FIR_filter</A> <I>Design a FIR highpass filter of order <TT>order</TT> and cut-off freqeuncy <TT>freq</TT>.</I>
<LI><A HREF="design_lowpass_FIR_filter.html">design_lowpass_FIR_filter</A> <I>Design a FIR lowpass filter of order <TT>order</TT> and cut-off freqeuncy <TT>freq</TT>.</I>
<LI><A HREF="Hz2Mel.html">Hz2Mel</A> <I>Convert Hertz to Mel.</I>
<LI><A HREF="Mel2Hz.html">Mel2Hz</A> <I> Convert Mel to Hertz.</I>
<LI><A HREF="fbank2melcep.html">fbank2melcep</A> <I>Compute the dicrete cosine transform of log Mel-scale filter bank output to get the Mel cepstral coeffecients for a frame of speech.</I>
<LI><A HREF="fft2fbank.html">fft2fbank</A> <I>Given a Mel filter bank description, bin the FFT coefficients to compute the output of the filters.</I>
<LI><A HREF="make_mel_triangular_filter.html">make_mel_triangular_filter</A> <I>Make a triangular Mel scale filter.</I>
<LI><A HREF="sig2fbank.html">sig2fbank</A> <I>Calculate the (log) energy (or power) in each channel of a Mel scale filter bank for a frame of speech.</I>
<LI><A HREF="sig2fft.html">sig2fft</A> <I>Calculate the energy (or power) spectrum of a frame of speech.</I>
<LI><A HREF="EST_WindowFunc.html">EST_WindowFunc</A> <I>Function which creates a window</I>
<LI><A HREF="add_after.html">add_after</A> <I>Add a item after node <parameter>n</parameter>, and return the new item.</I>
<LI><A HREF="add_before.html">add_before</A> <I>Add a item before node <parameter>n</parameter>, and return the new item.</I>
<LI><A HREF="first.html">first</A> <I>return first item in <parameter>n</parameter>'s relation</I>
<LI><A HREF="first.2.html">first</A> <I>return first item of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="in_list.html">in_list</A> <I>Given a node <parameter>l</parameter>, return true if <parameter>c</parameter> after it in a list relation.</I>
<LI><A HREF="last.html">last</A> <I>return last item in <parameter>n</parameter>'s relation</I>
<LI><A HREF="last.2.html">last</A> <I>return last item of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="next.2.html">next</A> <I>return next item of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="next.html">next</A> <I>return next item of <parameter>n</parameter></I>
<LI><A HREF="prev.2.html">prev</A> <I>return previous item of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="prev.html">prev</A> <I>return previous item of <parameter>n</parameter></I>
<LI><A HREF="remove_item_list.html">remove_item_list</A> <I>Remove the given item</I>
<LI><A HREF="append_daughter.2.html">append_daughter</A> <I>Add a daughter to node <parameter>n</parameter> as seen from relation <parameter>relname</parameter>, after any existing daughters, and return the next daughter.</I>
<LI><A HREF="append_daughter.html">append_daughter</A> <I>Add a daughter to node <parameter>n</parameter>, after any existing daughters, and return the next daughter.</I>
<LI><A HREF="prepend_daughter.2.html">prepend_daughter</A> <I>Add a daughter to node <parameter>n</parameter> as seen from relation <parameter>relname</parameter>, before any existing daughters, and return the next daughter.</I>
<LI><A HREF="prepend_daughter.html">prepend_daughter</A> <I>Add a daughter to node <parameter>n</parameter>, before any existing daughters, and return the next daughter.</I>
<LI><A HREF="daughter1.2.html">daughter1</A> <I>return first daughter of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="daughter1.html">daughter1</A> <I>return first daughter of <parameter>n</parameter></I>
<LI><A HREF="daughter2.html">daughter2</A> <I>return second daughter of <parameter>n</parameter></I>
<LI><A HREF="daughter2.2.html">daughter2</A> <I>return second daughter of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="daughtern.2.html">daughtern</A> <I>return last daughter of <parameter>n</parameter></I>
<LI><A HREF="daughtern.html">daughtern</A> <I>return nth daughter of <parameter>n</parameter></I>
<LI><A HREF="daughtern.3.html">daughtern</A> <I>return last daughter of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="first_leaf.html">first_leaf</A> <I>return the first leaf (terminal node) which is dominated by <parameter>n</parameter>.</I>
<LI><A HREF="in_tree.html">in_tree</A> <I>Given a node <parameter>t</parameter>, return true if <parameter>c</parameter> is under it in a tree </I>
<LI><A HREF="last_leaf.html">last_leaf</A> <I>return the last leaf (terminal node) which is dominated by <parameter>n</parameter>.</I>
<LI><A HREF="next_leaf.html">next_leaf</A> <I>Return next leaf in tree given <parameter>n</parameter>.</I>
<LI><A HREF="next_sibling.2.html">next_sibling</A> <I>return next sibling (sister) of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="next_sibling.html">next_sibling</A> <I>return next sibling (sister) of <parameter>n</parameter></I>
<LI><A HREF="num_leaves.html">num_leaves</A> <I>Return number of leaves (terminal nodes) under <parameter>n</parameter></I>
<LI><A HREF="parent.html">parent</A> <I>return parent of <parameter>n</parameter></I>
<LI><A HREF="parent.2.html">parent</A> <I>return parent of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="prev_sibling.html">prev_sibling</A> <I>return previous sibling (sister) of <parameter>n</parameter></I>
<LI><A HREF="prev_sibling.2.html">prev_sibling</A> <I>return previous sibling (sistem) of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="root.html">root</A> <I>return root node of treeprevious sibling (sister) of <parameter>n</parameter></I>
<LI><A HREF="root.2.html">root</A> <I>return root of tree of <parameter>n</parameter> as seen from relation <parameter>relname</parameter> </I>
<LI><A HREF="energy.html">energy</A> <I>Calculate the rms energy for each frame of the waveform.</I>
<LI><A HREF="fbank.html">fbank</A> <I>Mel scale filter bank analysis.</I>
<LI><A HREF="melcep.html">melcep</A> <I>Mel scale cepstral analysis via filter bank analysis.</I>
<LI><A HREF="power.html">power</A> <I>Calculate the power for each frame of the waveform.</I>
<LI><A HREF="sig2coef.html">sig2coef</A> <I>Produce a single set of coefficents from a waveform.</I>
<LI><A HREF="sigpr_base.html">sigpr_base</A> <I>Produce multiple coefficients from a waveform by repeated calls to sig2coef.</I>
<LI><A HREF="EST_HashFunctions.html#DefaultHash">Hash Tables::EST_HashFunctions::DefaultHash</A> <I>A generally useful hash function</I>
<LI><A HREF="EST_HashFunctions.html#StringHash">Hash Tables::EST_HashFunctions::StringHash</A> <I>A hash function for strings</I>
<LI><A HREF="EST_THash.html#(*p_hash_function)">Hash Tables::EST_THash::(*p_hash_function)</A> <I>The hash function to use on this table</I>
<LI><B>EST_THash:</B>
<UL>
<LI><A HREF="EST_THash.html#EST_THash">Hash Tables::EST_THash::EST_THash</A> <I>Create a copy</I>
<LI><A HREF="EST_THash.html#EST_THash">Hash Tables::EST_THash::EST_THash</A> <I>Create a table with the given number of buckets.</I>
</UL>
<LI><A HREF="EST_THash.html#move_pointer_forwards">move_pointer_forwards</A> <I>Move pointer forwards, at the end of the bucket, move down</I>
<LI><A HREF="EST_THash.html#point_to_first">point_to_first</A> <I>Go to start of the table</I>
<LI><A HREF="EST_THash.html#points_at">points_at</A> <I>Return the key of this entry</I>
<LI><A HREF="EST_THash.html#points_to_something">points_to_something</A> <I>We are at the end if the pointer ever becomes NULL</I>
<LI><A HREF="EST_THash.html#skip_blank">skip_blank</A> <I>Shift to point at something</I>
<LI><A HREF="EST_THash.html#move_pointer_forwards">move_pointer_forwards</A> <I>Move pointer forwards, at the end of the bucket, move down</I>
<LI><A HREF="EST_THash.html#point_to_first">point_to_first</A> <I>Go to start of the table</I>
<LI><A HREF="EST_THash.html#points_at">points_at</A> <I>Return the contents of this entry</I>
<LI><A HREF="EST_THash.html#points_to_something">points_to_something</A> <I>We are at the end if the pointer ever becomes NULL</I>
<LI><A HREF="EST_THash.html#skip_blank">skip_blank</A> <I>Shift to point at something</I>
<LI><A HREF="EST_THash.html#add_item">Hash Tables::EST_THash::add_item</A> <I>Add an entry to the table</I>
<LI><A HREF="EST_THash.html#clear">Hash Tables::EST_THash::clear</A> <I>Empty the table</I>
<LI><A HREF="EST_THash.html#copy">Hash Tables::EST_THash::copy</A> <I>Copy all entries</I>
<LI><A HREF="EST_THash.html#dump">Hash Tables::EST_THash::dump</A> <I>Print the table to <parameter>stream</parameter> in a human readable format</I>
<LI><A HREF="EST_THash.html#map">Hash Tables::EST_THash::map</A> <I>Apply <parameter>func</parameter> to each entry in the table</I>
<LI><A HREF="EST_THash.html#num_entries">Hash Tables::EST_THash::num_entries</A> <I>Return the total number of entries in the table</I>
<LI><A HREF="EST_THash.html#operator = ">Hash Tables::EST_THash::operator = </A> <I>Assignment is a copy operation</I>
<LI><A HREF="EST_THash.html#present">Hash Tables::EST_THash::present</A> <I>Does the key have an entry?</I>
<LI><A HREF="EST_THash.html#remove_item">Hash Tables::EST_THash::remove_item</A> <I>Remove an entry from the table</I>
<LI><B>val:</B>
<UL>
<LI><A HREF="EST_THash.html#val">Hash Tables::EST_THash::val</A> <I>Return the value associated with the key.</I>
<LI><A HREF="EST_THash.html#val">Hash Tables::EST_THash::val</A> <I>Return the value associated with the key</I>
</UL>
<LI><A HREF="EST_THash.html#~EST_THash">Hash Tables::EST_THash::~EST_THash</A> <I>Destroy the table</I>
<LI><A HREF="EST_TStringHash.html#EST_TStringHash">Hash Tables::EST_TStringHash::EST_TStringHash</A> <I>Create a string hash table of <parameter>size</parameter> buckets</I>
<LI><A HREF="inv_lpc_filter.html">inv_lpc_filter</A> <I>Filter the waveform using a single set of coefficients so as to produce a residual signal.</I>
<LI><A HREF="inv_lpc_filter_ola.html">inv_lpc_filter_ola</A> <I>Produce a residual from a track of linear prediction coefficients and a signal using an overlap add technique.</I>
<LI><A HREF="lpc_filter.html">lpc_filter</A> <I>Synthesize a signal from a single set of linear prediction coefficients and the residual values.</I>
<LI><A HREF="lpc_filter_1.html">lpc_filter_1</A> <I>Synthesize a signal from a track of linear prediction coefficients.</I>
<LI><A HREF="lpc_filter_fast.html">lpc_filter_fast</A> <I>Synthesize a signal from a track of linear prediction coefficients.</I>
<LI><A HREF="ref2area.html">ref2area</A> <I>An approximation of the area is calculate by skipping the denominator in the formula.</I>
<LI><A HREF="ref2logarea.html">ref2logarea</A> <I>The logs of the areas.</I>
<LI><A HREF="ref2truearea.html">ref2truearea</A> <I>The area according to the formula.</I>
<LI><A HREF="lpc2cep.html">lpc2cep</A> <I>Calulate cepstral coefficients from lpc coefficients.</I>
<LI><A HREF="lpc2lsf.html">lpc2lsf</A> <I>Calculate line spectral frequencies from linear prediction coefficients.</I>
<LI><A HREF="lpc2ref.html">lpc2ref</A> <I>Calculate the reflection coefficients from the lpc coefficients.</I>
<LI><A HREF="lsf2lpc.html">lsf2lpc</A> <I>Calculate line spectral frequencies from linear prediction coefficients.</I>
<LI><A HREF="ref2lpc.html">ref2lpc</A> <I>Calculate the linear prediction coefficients from the reflection coefficients.</I>
<LI><A HREF="sig2lpc.2.html">sig2lpc</A> <I>Produce a set linear prediction coefficients from a frame of speech waveform.</I>
<LI><A HREF="sig2lpc.html">sig2lpc</A> <I>Produce the full set of linear prediction coefficients from a frame of speech waveform.</I>
<LI><A HREF="sig2ref.html">sig2ref</A> <I>Produce a set of reflection coefficients from a frame of speech waveform.</I>
<LI><A HREF="simple_mean_smooth.html">simple_mean_smooth</A> <I>Filters the waveform by means of median smoothing.</I>
<LI><A HREF="EST_post_deemphasis.html">EST_post_deemphasis</A> <I>Post process to get the original back (eg after resynthesis)</I>
<LI><A HREF="EST_pre_emphasis.html">EST_pre_emphasis</A> <I>Pre process to emphasise higher frequencies</I>
<LI><B>getFloat:</B>
<UL>
<LI><A HREF="Safefeatureaccessfunctions..html#getFloat">Non core feature funtionality.::Safe feature access functions.::getFloat</A> <I>Return the values as a float</I>
<LI><A HREF="Safefeatureaccessfunctions..html#getFloat">Non core feature funtionality.::Safe feature access functions.::getFloat</A> <I>Return the values as a float</I>
<LI><A HREF="Safefeatureaccessfunctions..html#getFloat">Non core feature funtionality.::Safe feature access functions.::getFloat</A> <I>Return the values as a float</I>
</UL>
<LI><B>getInteger:</B>
<UL>
<LI><A HREF="Safefeatureaccessfunctions..html#getInteger">Non core feature funtionality.::Safe feature access functions.::getInteger</A> <I>Return the values as an integerReturn the values as an integer</I>
<LI><A HREF="Safefeatureaccessfunctions..html#getInteger">Non core feature funtionality.::Safe feature access functions.::getInteger</A> <I>Return the values as a float</I>
</UL>
<LI><B>getString:</B>
<UL>
<LI><A HREF="Safefeatureaccessfunctions..html#getString">Non core feature funtionality.::Safe feature access functions.::getString</A> <I>Return the value as a string</I>
<LI><A HREF="Safefeatureaccessfunctions..html#getString">Non core feature funtionality.::Safe feature access functions.::getString</A> <I>Return the value as a string</I>
<LI><A HREF="Safefeatureaccessfunctions..html#getString">Non core feature funtionality.::Safe feature access functions.::getString</A> <I>Return the value as a string</I>
</UL>
<LI><B>getVal:</B>
<UL>
<LI><A HREF="Safefeatureaccessfunctions..html#getVal">Non core feature funtionality.::Safe feature access functions.::getVal</A> <I>Return the value as an EST_Val</I>
<LI><A HREF="Safefeatureaccessfunctions..html#getVal">Non core feature funtionality.::Safe feature access functions.::getVal</A> <I>Return the value as an EST_Val</I>
<LI><A HREF="Safefeatureaccessfunctions..html#getVal">Non core feature funtionality.::Safe feature access functions.::getVal</A> <I>Return the value as an EST_Val</I>
</UL>
<LI><A HREF="default_pda_options.html">default_pda_options</A> <I>Create a set sensible defaults for use in pda and icda.</I>
<LI><A HREF="icda.html">icda</A> <I>Top level intonation contour detection algorithm.</I>
<LI><A HREF="pda.html">pda</A> <I>Top level pitch (F0) detection algorithm.</I>
<LI><A HREF="smooth_phrase.html">smooth_phrase</A> <I>Smooth selected parts of an f0 contour.</I>
<LI><A HREF="smooth_portion.html">smooth_portion</A> <I>Smooth all the points in an F0 contour</I>
<LI><A HREF="srpd.html">srpd</A> <I>Super resolution pitch trackerer.</I>
<LI><A HREF="neg_zero_cross_pick.html">neg_zero_cross_pick</A> <I>Find times where waveform cross zero axis in negative direction.</I>
<LI><A HREF="pitchmark.2.html">pitchmark</A> <I>Find pitchmarks in Larynograph (lx) signal.</I>
<LI><A HREF="pitchmark.html">pitchmark</A> <I>Find pitchmarks in Larynograph (lx) signal.</I>
<LI><A HREF="pm_fill.html">pm_fill</A> <I>Produce a set of sensible pitchmarks.</I>
<LI><A HREF="pm_min_check.html">pm_min_check</A> <I>Remove pitchmarks which are too close together.</I>
<LI><A HREF="post_emphasis.html">post_emphasis</A> <I>Post-emphasis filtering.</I>
<LI><A HREF="post_emphasis.2.html">post_emphasis</A> <I>Post-emphasis filtering.</I>
<LI><A HREF="pre_emphasis.html">pre_emphasis</A> <I>Pre-emphasis filtering.</I>
<LI><A HREF="pre_emphasis.2.html">pre_emphasis</A> <I>Pre-emphasis filtering.</I>
<LI><A HREF="raw_spectrogram.html">raw_spectrogram</A> <I>Compute the power-spectrogram</I>
<LI><A HREF="scale_spectrogram.html">scale_spectrogram</A> <I>Manipulate the spectrogram to </I>
<LI><B>EST_TVector:</B>
<UL>
<LI><A HREF="EST_TVector.html#EST_TVector">Template vector::EST_TVector::EST_TVector</A> <I>construct from memory supplied by caller</I>
<LI><A HREF="EST_TVector.html#EST_TVector">Template vector::EST_TVector::EST_TVector</A> <I>default constructor</I>
<LI><A HREF="EST_TVector.html#EST_TVector">Template vector::EST_TVector::EST_TVector</A> <I>copy constructor</I>
<LI><A HREF="EST_TVector.html#EST_TVector">Template vector::EST_TVector::EST_TVector</A> <I>"size" constructor - make vector of size n</I>
</UL>
<LI><B>a_check:</B>
<UL>
<LI><A HREF="EST_TVector.html#a_check">a_check</A> <I>read/write non-const access operator: with bounds checking</I>
<LI><A HREF="EST_TVector.html#a_check">a_check</A> <I>read-only const access operator: with bounds checking</I>
</UL>
<LI><B>a_no_check:</B>
<UL>
<LI><A HREF="EST_TVector.html#a_no_check">a_no_check</A> <I>read/write non-const access operator: without bounds checking</I>
<LI><A HREF="EST_TVector.html#a_no_check">a_no_check</A> <I>read-only const access operator: without bounds checking</I>
</UL>
<LI><B>a_no_check_1:</B>
<UL>
<LI><A HREF="EST_TVector.html#a_no_check_1">a_no_check_1</A> <I>read/write non-const access operator: without bounds checking</I>
<LI><A HREF="EST_TVector.html#a_no_check_1">a_no_check_1</A> <I>read-only const access operator: without bounds checking</I>
</UL>
<LI><A HREF="EST_TVector.html#length">length</A> <I>number of items in vector</I>
<LI><A HREF="EST_TVector.html#n">n</A> <I>number of items in vector</I>
<LI><A HREF="EST_TVector.html#num_columns">num_columns</A> <I>number of items in vector</I>
<LI><A HREF="EST_TVector.html#operator () ">operator () </A> <I>read-only const access operator: return reference to nth member</I>
<LI><A HREF="EST_TVector.html#operator [] ">operator [] </A> <I>read/write non const access operator: return reference to nth member</I>
<LI><A HREF="EST_TVector.html#copy">Template vector::EST_TVector::copy</A> <I>private copy function, called from all other copying functions</I>
<LI><A HREF="EST_TVector.html#copy_data">Template vector::EST_TVector::copy_data</A> <I>just copy data, no resizing, no size check</I>
<LI><A HREF="EST_TVector.html#copy_section">Template vector::EST_TVector::copy_section</A> <I>Copy data in and out.</I>
<LI><A HREF="EST_TVector.html#default_vals">Template vector::EST_TVector::default_vals</A> <I>sets data and length to default values (0 in both cases)</I>
<LI><A HREF="EST_TVector.html#empty">Template vector::EST_TVector::empty</A> <I>Fill vector with default value</I>
<LI><A HREF="EST_TVector.html#fast_a_v">Template vector::EST_TVector::fast_a_v</A> <I>quick method for returning \(x[n]\)</I>
<LI><A HREF="EST_TVector.html#fill">Template vector::EST_TVector::fill</A> <I>Fill entire array will value <parameter>v</parameter></I>
<LI><A HREF="EST_TVector.html#integrity">Template vector::EST_TVector::integrity</A>
<LI><A HREF="EST_TVector.html#just_resize">Template vector::EST_TVector::just_resize</A> <I>resize the memory and reset the bounds, but don't set values</I>
<LI><A HREF="EST_TVector.html#memory">Template vector::EST_TVector::memory</A> <I>For when you absolutely have to have access to the memory</I>
<LI><A HREF="EST_TVector.html#operator != ">Template vector::EST_TVector::operator != </A> <I>is true if vectors are not equal size or a single elements isn't equal</I>
<LI><A HREF="EST_TVector.html#operator == ">Template vector::EST_TVector::operator == </A> <I>is true if vectors are equal size and all elements are equal</I>
<LI><A HREF="EST_TVector.html#operator=">Template vector::EST_TVector::operator=</A> <I>assignment operator</I>
<LI><A HREF="EST_TVector.html#resize">Template vector::EST_TVector::resize</A> <I>resize vector.</I>
<LI><A HREF="EST_TVector.html#save">Template vector::EST_TVector::save</A> <I>Save vector to file <parameter>filename</parameter></I>
<LI><A HREF="EST_TVector.html#set_values">Template vector::EST_TVector::set_values</A> <I>Get and set values from array</I>
<LI><A HREF="EST_TVector.html#sub_vector">Template vector::EST_TVector::sub_vector</A> <I>Create a sub vector</I>
<LI><A HREF="EST_TVector.html#vcell_pos">Template vector::EST_TVector::vcell_pos</A> <I>The memory access rule, in one place for easy reference</I>
<LI><A HREF="EST_TVector.html#~EST_TVector">Template vector::EST_TVector::~EST_TVector</A> <I>destructor</I>
<LI><A HREF="default_rfc_params.html">default_rfc_params</A> <I>Fill op with sensible default parameters for RFC analysis</I>
<LI><A HREF="fill_rise_fall_values.html">fill_rise_fall_values</A> <I>Fill op with sensible default parameters for RFC analysis </I>
<LI><A HREF="rfc_analysis.html">rfc_analysis</A> <I>Produce a set of RFC parameterized events given approximate event boundaries and a smoothed F0 contour.</I>
<LI><A HREF="rfc_synthesis.html">rfc_synthesis</A> <I>Generate an F0 contour given a list RFC events.</I>
<LI><A HREF="rfc_to_tilt.html">rfc_to_tilt</A> <I>Convert a single set of local RFC parameters to local tilt parameters.</I>
<LI><A HREF="rfc_to_tilt.2.html">rfc_to_tilt</A> <I>For each tilt events in ev_rfc, produce a set of Tiltparameters.</I>
<LI><A HREF="tilt_analysis.html">tilt_analysis</A> <I>Fill op with sensible default parameters for RFC analysis </I>
<LI><A HREF="tilt_synthesis.html">tilt_synthesis</A> <I>Generate an F0 contour given a list Tilt events.</I>
<LI><A HREF="tilt_to_rfc.2.html">tilt_to_rfc</A> <I>For each tilt events in ev_tilt, produce a set of RFC parameters.</I>
<LI><A HREF="tilt_to_rfc.html">tilt_to_rfc</A> <I>Convert a single set of local tilt parameters to local RFC parameters.</I>
<LI><A HREF="XML_Parser.html#XML_Parser">XML Parser::XML_Parser::XML_Parser</A> <I>Creator used by XML_Parser_Class::make_parser()</I>
<LI><A HREF="XML_Parser.html#context">XML Parser::XML_Parser::context</A> <I>Get the name of the nth enclosing element.</I>
<LI><A HREF="XML_Parser.html#get_error">XML Parser::XML_Parser::get_error</A> <I>Get the error message for the last error</I>
<LI><A HREF="XML_Parser.html#go">XML Parser::XML_Parser::go</A> <I>Run the parser.</I>
<LI><A HREF="XML_Parser.html#open">XML Parser::XML_Parser::open</A> <I>Open.</I>
<LI><A HREF="XML_Parser.html#track_contents">XML Parser::XML_Parser::track_contents</A> <I>Keep track of the content of open elements.</I>
<LI><A HREF="XML_Parser.html#track_context">XML Parser::XML_Parser::track_context</A> <I>Request that parser keep track of the currently open elements.</I>
<LI><A HREF="XML_Parser.html#~XML_Parser">XML Parser::XML_Parser::~XML_Parser</A> <I>Destructor, may close input if required</I>
<LI><B>make_parser:</B>
<UL>
<LI><A HREF="XML_Parser_Class.html#make_parser">make_parser</A> <I>Create a parser for a stdio input stream, giving a description for use in errors</I>
<LI><A HREF="XML_Parser_Class.html#make_parser">make_parser</A> <I>Create a parser for the RXP InputSource</I>
<LI><A HREF="XML_Parser_Class.html#make_parser">make_parser</A> <I>Create a parser for the RXP InputSource</I>
<LI><A HREF="XML_Parser_Class.html#make_parser">make_parser</A> <I>Create a parser for a stdio input stream</I>
</UL>
<LI><A HREF="XML_Parser_Class.html#cdata">cdata</A> <I>Called for unparsed character data sequences</I>
<LI><A HREF="XML_Parser_Class.html#document_close">document_close</A> <I>Called at the end of a document</I>
<LI><A HREF="XML_Parser_Class.html#document_open">document_open</A> <I>Called when starting a document</I>
<LI><A HREF="XML_Parser_Class.html#element">element</A> <I>Called for empty elements.</I>
<LI><A HREF="XML_Parser_Class.html#element_close">element_close</A> <I>Called when an element ends</I>
<LI><A HREF="XML_Parser_Class.html#element_open">element_open</A> <I>Called when an element starts</I>
<LI><A HREF="XML_Parser_Class.html#error">error</A> <I>Called when there is an error in parsing</I>
<LI><A HREF="XML_Parser_Class.html#pcdata">pcdata</A> <I>Called for parsed character data sequences</I>
<LI><A HREF="XML_Parser_Class.html#processing">processing</A> <I>Called for processing directives</I>
<LI><A HREF="XML_Parser_Class.html#XML_Parser_Class">XML Parser::XML_Parser_Class::XML_Parser_Class</A> <I>Create an object representing the class of parsers.</I>
<LI><A HREF="XML_Parser_Class.html#error">XML Parser::XML_Parser_Class::error</A> <I>This can be called from any of the callbacks to present "message" as an error through the error callback, thus getting filename and line information into the message</I>
<LI><A HREF="XML_Parser_Class.html#get_error">XML Parser::XML_Parser_Class::get_error</A> <I>Get the error message for the last error</I>
<LI><A HREF="XML_Parser_Class.html#open_entity">XML Parser::XML_Parser_Class::open_entity</A> <I>Do any neccessary remappings and open a stream which reads the given entity</I>
<LI><A HREF="XML_Parser_Class.html#register_id">XML Parser::XML_Parser_Class::register_id</A> <I>Add a mapping from entity ID (SYSTEM or PUBLIC) to filename.</I>
<LI><A HREF="XML_Parser_Class.html#registered_ids">XML Parser::XML_Parser_Class::registered_ids</A> <I>Fill in the list with the known entity ID mappings</I>
<LI><A HREF="XML_Parser_Class.html#try_and_open">XML Parser::XML_Parser_Class::try_and_open</A> <I>Utility which tries to open an entity called ID at places specified in the mapping of this parser class</I>
<LI><A HREF="add.html">add</A> <I>elementwise add</I>
<LI><A HREF="add.2.html">add</A> <I>elementwise add</I>
<LI><A HREF="build_RelationList_hash_table.html">build_RelationList_hash_table</A> <I>hashed relation lists for super speed</I>
<LI><A HREF="count_bracket_crossing.html">count_bracket_crossing</A> <I>Cummulate cross bracketing information between ref and test</I>
<LI><A HREF="cov_prod.html">cov_prod</A> <I>matrix product of two vectors (<TT>rows = length of first vector, </TT>cols = length of second vector)</I>
<LI><A HREF="cov_prod.2.html">cov_prod</A> <I>matrix product of two vectors (<TT>rows = length of first vector, </TT>cols = length of second vector)</I>
<LI><A HREF="diagonal.html">diagonal</A> <I>extract leading diagonal as a vector</I>
<LI><A HREF="diagonal.2.html">diagonal</A> <I>extract leading diagonal as a vector</I>
<LI><A HREF="diagonalise.html">diagonalise</A> <I>extract leading diagonal as a matrix</I>
<LI><A HREF="diagonalise.2.html">diagonalise</A> <I>extract leading diagonal as a matrix</I>
<LI><A HREF="est_seed.html">est_seed</A> <I>the user should use est_seed to seed the random number generatorthe user should use est_seed to seed the random number generator</I>
<LI><A HREF="eye.html">eye</A> <I>make already square matris into I without resizing</I>
<LI><A HREF="eye.2.html">eye</A> <I>make already square matris into I without resizing</I>
<LI><A HREF="inplace_diagonalise.html">inplace_diagonalise</A> <I>inplace diagonalise</I>
<LI><A HREF="inplace_diagonalise.2.html">inplace_diagonalise</A> <I>inplace diagonalise</I>
<LI><A HREF="inverse.html">inverse</A> <I>inverse</I>
<LI><A HREF="inverse.2.html">inverse</A> <I>inverse</I>
<LI><A HREF="make_random_diagonal_matrix.html">make_random_diagonal_matrix</A> <I>used for variance</I>
<LI><A HREF="make_random_diagonal_matrix.2.html">make_random_diagonal_matrix</A> <I>used for variance</I>
<LI><A HREF="make_random_matrix.2.html">make_random_matrix</A> <I>all elements are randomised</I>
<LI><A HREF="make_random_matrix.html">make_random_matrix</A> <I>all elements are randomised</I>
<LI><A HREF="make_random_symmetric_matrix.2.html">make_random_symmetric_matrix</A> <I>used for covariance</I>
<LI><A HREF="make_random_symmetric_matrix.html">make_random_symmetric_matrix</A> <I>used for covariance</I>
<LI><A HREF="make_random_vector.html">make_random_vector</A> <I>all elements are randomised</I>
<LI><A HREF="make_random_vector.2.html">make_random_vector</A> <I>all elements are randomised</I>
<LI><A HREF="matrix_max.html">matrix_max</A> <I>find largest element</I>
<LI><A HREF="matrix_max.2.html">matrix_max</A> <I>find largest element</I>
<LI><A HREF="operator.html">operator*</A> <I>vector dot product</I>
<LI><A HREF="operator.2.html">operator*</A> <I>vector dot product</I>
<LI><A HREF="polynomial_fit.html">polynomial_fit</A> <I>least squares fit</I>
<LI><A HREF="polynomial_fit.2.html">polynomial_fit</A> <I>weighted least squares fit</I>
<LI><A HREF="polynomial_fit.3.html">polynomial_fit</A> <I>least squares fit</I>
<LI><A HREF="polynomial_fit.4.html">polynomial_fit</A> <I>weighted least squares fit</I>
<LI><A HREF="pseudo_inverse.html">pseudo_inverse</A> <I>pseudo inverse (for non-square matrices)</I>
<LI><A HREF="pseudo_inverse.2.html">pseudo_inverse</A> <I>pseudo inverse (for non-square matrices)</I>
<LI><A HREF="quote_string.html">quote_string</A> <I>Quote a string with given quotes and escape character</I>
<LI><A HREF="scfg_bracketing_only.html">scfg_bracketing_only</A> <I>From a full parse, extract the string with bracketing only</I>
<LI><A HREF="scfg_parse.2.html">scfg_parse</A> <I>Parse the given string using the given <!1><A HREF="EST_SCFG.html">EST_SCFG</A></I>
<LI><A HREF="scfg_parse.html">scfg_parse</A> <I>Parse a given string using the given grammar</I>
<LI><A HREF="scfg_parse.3.html">scfg_parse</A> <I>Parse named features in (list) relation Word into (tree) relation Syntax</I>
<LI><A HREF="set.html">set</A> <I>assignment operator: fill track with values in list <parameter>s</paramater></I>
<LI><A HREF="singular.html">singular</A> <I>not implemented ??</I>
<LI><A HREF="singular.2.html">singular</A> <I>not implemented ??</I>
<LI><A HREF="stack_matrix.html">stack_matrix</A> <I>stack columns on top of each other to make a vector</I>
<LI><A HREF="stack_matrix.2.html">stack_matrix</A> <I>stack columns on top of each other to make a vector</I>
<LI><A HREF="subtract.html">subtract</A> <I>elementwise subtract</I>
<LI><A HREF="subtract.2.html">subtract</A> <I>elementwise subtract</I>
<LI><A HREF="sum.2.html">sum</A> <I>sum of elements</I>
<LI><A HREF="sum.html">sum</A> <I>sum of elements</I>
<LI><A HREF="symmetrize.2.html">symmetrize</A> <I>enforce symmetry</I>
<LI><A HREF="symmetrize.html">symmetrize</A> <I>enforce symmetry</I>
<LI><A HREF="transpose.2.html">transpose</A> <I>exchange rows and columns</I>
<LI><A HREF="transpose.html">transpose</A> <I>exchange rows and columns</I>
<LI><A HREF="utterance_xml_try_and_open.html">utterance_xml_try_and_open</A> <I>Export some RXP functionality for use in festival.</I>
<LI><A HREF="vector_max.html">vector_max</A> <I>find largest element</I>
</UL>
<H2>Variables</H2>
<UL>
<LI><A HREF="EST_ChannelType.html#channel_duration">Channel Types::EST_ChannelType::channel_duration</A> <I>Duration of section of signal</I>
<LI><A HREF="EST_ChannelType.html#channel_energy">Channel Types::EST_ChannelType::channel_energy</A> <I>RMS energy of section of signal</I>
<LI><A HREF="EST_ChannelType.html#channel_f0">Channel Types::EST_ChannelType::channel_f0</A> <I>F0 in Hz</I>
<LI><A HREF="EST_ChannelType.html#channel_frame">Channel Types::EST_ChannelType::channel_frame</A> <I>Number of related frame in another track</I>
<LI><A HREF="EST_ChannelType.html#channel_length">Channel Types::EST_ChannelType::channel_length</A> <I>Length of section in samples</I>
<LI><A HREF="EST_ChannelType.html#channel_offset">Channel Types::EST_ChannelType::channel_offset</A> <I>Offset from frame center to center of window</I>
<LI><A HREF="EST_ChannelType.html#channel_order">Channel Types::EST_ChannelType::channel_order</A> <I>order of analysis</I>
<LI><A HREF="EST_ChannelType.html#channel_peak">Channel Types::EST_ChannelType::channel_peak</A> <I>Peak amplitude</I>
<LI><A HREF="EST_ChannelType.html#channel_power">Channel Types::EST_ChannelType::channel_power</A> <I>RMS power of section of signal</I>
<LI><A HREF="EST_ChannelType.html#channel_time">Channel Types::EST_ChannelType::channel_time</A> <I>Time in seconds this frame refers to</I>
<LI><A HREF="EST_ChannelType.html#channel_unknown">Channel Types::EST_ChannelType::channel_unknown</A> <I>Value to return for errors, never occurs in TrackMaps</I>
<LI><A HREF="EST_ChannelType.html#channel_voiced">Channel Types::EST_ChannelType::channel_voiced</A> <I>Voicing decision</I>
<LI><A HREF="EST_ChannelType.html#first_channel_type">Channel Types::EST_ChannelType::first_channel_type</A> <I>So we know how many there are</I>
<LI><A HREF="EST_ChannelType.html#num_channel_types">Channel Types::EST_ChannelType::num_channel_types</A> <I>Can be used to size arrays etc</I>
<LI><A HREF="EST_CoefficientType.html#cot_cepstrum">Channel Types::EST_CoefficientType::cot_cepstrum</A> <I>Cepstral coefficients</I>
<LI><A HREF="EST_CoefficientType.html#cot_fbank">Channel Types::EST_CoefficientType::cot_fbank</A> <I>Mel Scale filter bank</I>
<LI><A HREF="EST_CoefficientType.html#cot_filter">Channel Types::EST_CoefficientType::cot_filter</A> <I>Unknown filter type</I>
<LI><A HREF="EST_CoefficientType.html#cot_first">Channel Types::EST_CoefficientType::cot_first</A> <I>guaranteed to be the first known type</I>
<LI><A HREF="EST_CoefficientType.html#cot_free">Channel Types::EST_CoefficientType::cot_free</A> <I>Guaranteed to be one more than last legal coefficient type</I>
<LI><A HREF="EST_CoefficientType.html#cot_lpc">Channel Types::EST_CoefficientType::cot_lpc</A> <I>Linear prediction filter</I>
<LI><A HREF="EST_CoefficientType.html#cot_lsf">Channel Types::EST_CoefficientType::cot_lsf</A> <I>Line spectral pairs</I>
<LI><A HREF="EST_CoefficientType.html#cot_melcepstrum">Channel Types::EST_CoefficientType::cot_melcepstrum</A> <I>Mel Scale Cepstrum</I>
<LI><A HREF="EST_CoefficientType.html#cot_reflection">Channel Types::EST_CoefficientType::cot_reflection</A> <I>reflection coefficients</I>
<LI><A HREF="EST_CoefficientType.html#cot_tubearea">Channel Types::EST_CoefficientType::cot_tubearea</A> <I>Tube areas for filter</I>
<LI><A HREF="EST_CoefficientType.html#cot_user1">Channel Types::EST_CoefficientType::cot_user1</A> <I>Free for experimentation</I>
<LI><A HREF="EST_CoefficientType.html#cot_user2">Channel Types::EST_CoefficientType::cot_user2</A> <I>Free for experimentation</I>
<LI><A HREF="EST_FeatureSample.html#set number of samples to be held in object and allocate space for storing them ">set number of samples to be held in object and allocate space for storing them </A>
<LI><A HREF="EST_Item_Content.html#f">EST_Item_Content::f</A> <I>General features for this item</I>
<LI><A HREF="EST_Regex.html#compiled">EST_Regex::compiled</A> <I>The compiled form</I>
<LI><A HREF="EST_Regex.html#compiled_match">EST_Regex::compiled_match</A> <I>Compiled form for whole string match</I>
<LI><A HREF="EST_Relation.html#f">EST_Relation::f</A> <I>Features which belong to the relation rather than its items</I>
<LI><A HREF="EST_SCFG.html#rules">rules</A> <I>The rules themselves</I>
<LI><A HREF="EST_SCFG_Chart.html#edges">EST_SCFG_Chart::edges</A> <I>Index of edges by vertex start x vertex end x nonterminal</I>
<LI><A HREF="EST_SCFG_Chart.html#emptyedge">EST_SCFG_Chart::emptyedge</A> <I>An empty edge, denotes 0 probability edge</I>
<LI><A HREF="EST_SCFG_Chart.html#grammar">EST_SCFG_Chart::grammar</A> <I>pointer to grammar</I>
<LI><A HREF="EST_SCFG_Chart.html#grammar_local">EST_SCFG_Chart::grammar_local</A> <I>TRUE is grammar was created internally, FALSE is can't be freed</I>
<LI><A HREF="EST_SCFG_Chart.html#n_vertices">EST_SCFG_Chart::n_vertices</A> <I>Number of vertices (number of words + 1)</I>
<LI><A HREF="EST_SCFG_Chart.html#wfst">EST_SCFG_Chart::wfst</A> <I>Index of basic symbols indexed by (start) vertice</I>
<LI><A HREF="EST_SCFG_traintest.html#d">EST_SCFG_traintest::d</A> <I>Partial (denominator) for reestimation</I>
<LI><A HREF="EST_SCFG_traintest.html#inside">EST_SCFG_traintest::inside</A> <I>Index for inside probabilities</I>
<LI><A HREF="EST_SCFG_traintest.html#n">EST_SCFG_traintest::n</A> <I>Partial (numerator) for reestimation</I>
<LI><A HREF="EST_SCFG_traintest.html#outside">EST_SCFG_traintest::outside</A> <I>Index for outside probabilities</I>
<LI><A HREF="EST_Server.html#sm_client">EST_Server::Mode::sm_client</A> <I>Client end of the connetion</I>
<LI><A HREF="EST_Server.html#sm_fork">EST_Server::Mode::sm_fork</A> <I>For off a process for each client</I>
<LI><A HREF="EST_Server.html#sm_interleaved">EST_Server::Mode::sm_interleaved</A> <I>Answer requests from several clients, as requests arrive</I>
<LI><A HREF="EST_Server.html#sm_sequential">EST_Server::Mode::sm_sequential</A> <I>Answer one client at a time</I>
<LI><A HREF="EST_Server.html#sm_threded">EST_Server::Mode::sm_threded</A> <I>Muti-threaded (not implemented)</I>
<LI><A HREF="EST_Server.html#sm_unknown">EST_Server::Mode::sm_unknown</A> <I>Bizzare state</I>
<LI><A HREF="EST_Server.html#p_entry">EST_Server::p_entry</A> <I>Then server we are connected to</I>
<LI><A HREF="Entry.html#address">EST_ServiceTable::Entry::address</A> <I>Numeric IP address (<TT></TT><TT></TT><TT></TT><TT></TT><TT></TT><TT></TT>)</I>
<LI><A HREF="Entry.html#cookie">EST_ServiceTable::Entry::cookie</A> <I>A random string to send as authorisation</I>
<LI><A HREF="Entry.html#hostname">EST_ServiceTable::Entry::hostname</A> <I>Human readable hostname</I>
<LI><A HREF="Entry.html#name">EST_ServiceTable::Entry::name</A> <I>Name of the server</I>
<LI><A HREF="Entry.html#port">EST_ServiceTable::Entry::port</A> <I>TCP port number</I>
<LI><A HREF="Entry.html#type">EST_ServiceTable::Entry::type</A> <I>Type of server (eg `fringe')</I>
<LI><A HREF="EST_ServiceTable.html#entries">EST_ServiceTable::entries</A> <I>Table of available Fringe servers</I>
<LI><A HREF="EST_String.html#Empty">EST_String::Empty</A> <I>Constant empty string</I>
<LI><A HREF="EST_String.html#b">b</A>
<LI><A HREF="EST_String.html#max">max</A>
<LI><A HREF="EST_String.html#memory">EST_String::memory</A> <I>Smart pointer to actual memory</I>
<LI><A HREF="EST_String.html#size">EST_String::size</A> <I>Size of string</I>
<LI><A HREF="EST_String.html#version">EST_String::version</A> <I>Global version string</I>
<LI><A HREF="EST_TBuffer.html#p_buffer">EST_TBuffer.h::EST_TBuffer::p_buffer</A> <I>Pointer to memory</I>
<LI><A HREF="EST_TBuffer.html#p_size">EST_TBuffer.h::EST_TBuffer::p_size</A> <I>Current size</I>
<LI><A HREF="EST_TBuffer.html#p_step">EST_TBuffer.h::EST_TBuffer::p_step</A> <I>Amount to grow by (if negative it is a percentage)</I>
<LI><A HREF="EST_TDeque.html#Filler">EST_TDeque::Filler</A> <I>Used to fill empty spaces when possible</I>
<LI><A HREF="EST_TIterator.html#cont">EST_TIterator::cont</A> <I>The container we are looking at</I>
<LI><A HREF="EST_TIterator.html#pointer">EST_TIterator::pointer</A> <I>Structure defined by the container class whcih contains the current state of the iteration</I>
<LI><A HREF="EST_TIterator.html#pos">EST_TIterator::pos</A> <I>Position in the structure.</I>
<LI><A HREF="EST_TKVL.html#default_key">EST_TKVL::default_key</A> <I>default value, returned when there is no such entry</I>
<LI><A HREF="EST_TKVL.html#default_val">EST_TKVL::default_val</A> <I>default value, returned when there is no such entry</I>
<LI><A HREF="EST_TMatrix.html#p_num_rows">EST_TMatrix::p_num_rows</A> <I>Visible shape</I>
<LI><A HREF="EST_TMatrix.html#p_row_step">EST_TMatrix::p_row_step</A> <I>How to access the memory</I>
<LI><A HREF="General.html#EST_Token_Default_PrePunctuationSymbols">EST_Token_Default_PrePunctuationSymbols</A>
<LI><A HREF="General.html#EST_Token_Default_PunctuationSymbols">EST_Token_Default_PunctuationSymbols</A>
<LI><A HREF="General.html#EST_Token_Default_SingleCharSymbols">EST_Token_Default_SingleCharSymbols</A>
<LI><A HREF="EST_Token_Default_WhiteSpaceChars.html">EST_Token_Default_WhiteSpaceChars</A> <I>The default whitespace characters</I>
<LI><A HREF="EST_TrackMap.html#Table of type to position pairs">Table of type to position pairs</A>
<LI><A HREF="EST_TrackMap.html#p_map">EST_TrackMap::p_map</A> <I>The map itself</I>
<LI><A HREF="EST_TrackMap.html#p_offset">EST_TrackMap::p_offset</A> <I>Subtracted from the values in the parent</I>
<LI><A HREF="EST_TrackMap.html#p_parent">EST_TrackMap::p_parent</A> <I>Parent is looked at if this map doesn't define the position</I>
<LI><A HREF="EST_TrieNode.html#w">EST_TrieNode::w</A>
<LI><A HREF="EST_Utterance.html#Utterance access">EST_Utterance::Utterance access</A>
<UL><LI><A HREF="EST_Utterance.html#f">f</A> <I>Utterance level features</I>
<LI><A HREF="EST_Utterance.html#relations">relations</A> <I>The list of named relations</I>
</UL><LI><A HREF="EST_Viterbi_Decoder.html#debug">EST_Viterbi_Decoder::debug</A> <I>very detailed info - for developers</I>
<LI><A HREF="EST_Viterbi_Decoder.html#do_pruning">EST_Viterbi_Decoder::do_pruning</A> <I>pruning parameters</I>
<LI><A HREF="EST_Viterbi_Decoder.html#f">EST_Viterbi_Decoder::f</A> <I>For holding vlaues to pass to user called functions</I>
<LI><A HREF="EST_Viterbi_Decoder.html#trace">EST_Viterbi_Decoder::trace</A> <I>less detailed info than debug - for users</I>
<LI><A HREF="EST_connect_status.html#connect_error">EST_connect_status::connect_error</A> <I>The file was not written successfully</I>
<LI><A HREF="EST_connect_status.html#connect_not_allowed_error">EST_connect_status::connect_not_allowed_error</A> <I>Connection failed</I>
<LI><A HREF="EST_connect_status.html#connect_not_found_error">EST_connect_status::connect_not_found_error</A> <I>Connection failed</I>
<LI><A HREF="EST_connect_status.html#connect_ok">EST_connect_status::connect_ok</A> <I>Connection made</I>
<LI><A HREF="EST_connect_status.html#connect_system_error">EST_connect_status::connect_system_error</A> <I>System failure of some kind</I>
<LI><A HREF="EST_default_channel_names.html">EST_default_channel_names</A> <I>Definition of standard names we use for channels</I>
<LI><A HREF="EST_error_behaviour.html#est_errors_allowed">EST_error_behaviour::est_errors_allowed</A> <I>Function will throw errors when feature doesn't exist</I>
<LI><A HREF="EST_error_behaviour.html#est_errors_checked">EST_error_behaviour::est_errors_checked</A> <I>Function will not normally return an error unless something really bad has gone wrong.</I>
<LI><A HREF="EST_error_behaviour.html#est_errors_never">EST_error_behaviour::est_errors_never</A> <I>No fatal errors allowed.</I>
<LI><A HREF="EST_read_status.html#read_error">EST_read_status::read_error</A> <I>An error occurred while reading</I>
<LI><A HREF="EST_read_status.html#read_format_error">EST_read_status::read_format_error</A> <I>The file exists but is not in the format specified</I>
<LI><A HREF="EST_read_status.html#read_not_found_error">EST_read_status::read_not_found_error</A> <I>The file does not exist</I>
<LI><A HREF="EST_read_status.html#read_ok">EST_read_status::read_ok</A> <I>The file was read in successfully</I>
<LI><A HREF="EST_rw_state.html#rws_failed">EST_rw_state::rws_failed</A> <I>failed</I>
<LI><A HREF="EST_rw_state.html#rws_ok">EST_rw_state::rws_ok</A> <I>ok</I>
<LI><A HREF="EST_rw_state.html#rws_partial">EST_rw_state::rws_partial</A> <I>partial</I>
<LI><A HREF="EST_track_aux.h.html#VAL_REGISTER_CLASS_DCLS">VAL_REGISTER_CLASS_DCLS</A>
<LI><A HREF="EST_write_status.html#write_error">EST_write_status::write_error</A> <I>The file was not written successfully</I>
<LI><A HREF="EST_write_status.html#write_fail">EST_write_status::write_fail</A> <I>The file was not written successfully</I>
<LI><A HREF="EST_write_status.html#write_ok">EST_write_status::write_ok</A> <I>The file was written successfully</I>
<LI><A HREF="EST_write_status.html#write_partial">EST_write_status::write_partial</A> <I>A valid file was created, but only some of the requested data is in there</I>
<LI><A HREF="EST_Hash_Pair.html#k">Hash Tables::EST_Hash_Pair::k</A> <I>The key</I>
<LI><A HREF="EST_Hash_Pair.html#next">Hash Tables::EST_Hash_Pair::next</A> <I>Pointer used to chain entries into buckets</I>
<LI><A HREF="EST_Hash_Pair.html#v">Hash Tables::EST_Hash_Pair::v</A> <I>The value</I>
<LI><A HREF="EST_THash.html#Dummy_Value">Hash Tables::EST_THash::Dummy_Value</A> <I>Something to return when there is no entry in the table</I>
<LI><A HREF="EST_THash.html#p_buckets">Hash Tables::EST_THash::p_buckets</A> <I>Pointer to an array of <variable>p_num_buckets</variable>buckets</I>
<LI><A HREF="EST_THash.html#p_num_buckets">Hash Tables::EST_THash::p_num_buckets</A> <I>Number of buckets</I>
<LI><A HREF="EST_THash.html#p_num_entries">Hash Tables::EST_THash::p_num_entries</A> <I>Total number of entries</I>
<LI><A HREF="Safefeatureaccessfunctions..html#efs_error">Non core feature funtionality.::Safe feature access functions.::EST_feat_status::efs_error</A> <I>An error occured and was caught</I>
<LI><A HREF="Safefeatureaccessfunctions..html#efs_not_set">Non core feature funtionality.::Safe feature access functions.::EST_feat_status::efs_not_set</A> <I>No value for feature, default returned</I>
<LI><A HREF="Safefeatureaccessfunctions..html#efs_ok">Non core feature funtionality.::Safe feature access functions.::EST_feat_status::efs_ok</A> <I>All OK, value returned</I>
<LI><A HREF="Noncorefeaturefuntionality..html#VAL_REGISTER_FUNCPTR_DCLS">VAL_REGISTER_FUNCPTR_DCLS</A>
<LI><A HREF="RXalpha.html">RXalpha</A> <I>Sequence of alphabetic characters</I>
<LI><A HREF="RXalphanum.html">RXalphanum</A> <I>Sequence of letters and/or digits</I>
<LI><A HREF="RXdouble.html">RXdouble</A> <I>Floating point number</I>
<LI><A HREF="RXidentifier.html">RXidentifier</A> <I>Initial letter or underscore followed by letters underscores or digits</I>
<LI><A HREF="RXint.html">RXint</A> <I>Integer</I>
<LI><A HREF="RXlowercase.html">RXlowercase</A> <I>Sequence of lower case alphabetic characters</I>
<LI><A HREF="RXuppercase.html">RXuppercase</A> <I>Sequence of upper case alphabetic characters</I>
<LI><A HREF="RXwhite.html">RXwhite</A> <I>White space</I>
<LI><A HREF="EST_TVector.html#def_val">Template vector::EST_TVector::def_val</A> <I>default value, used for filling matrix after resizing</I>
<LI><A HREF="EST_TVector.html#error_return">Template vector::EST_TVector::error_return</A> <I>A reference to this variable is returned if you try and access beyond the bounds of the matrix.</I>
<LI><A HREF="EST_TVector.html#p_memory">Template vector::EST_TVector::p_memory</A> <I>Pointer to the start of the vector.</I>
<LI><A HREF="EST_TVector.html#p_num_columns">Template vector::EST_TVector::p_num_columns</A> <I>Visible shape</I>
<LI><A HREF="EST_TVector.html#p_offset">Template vector::EST_TVector::p_offset</A> <I>How to access the memory</I>
<LI><A HREF="XML_Parser.html#current_bit">XML Parser::XML_Parser::current_bit</A> <I>The piece of markup being processed</I>
<LI><A HREF="XML_Parser.html#data">XML Parser::XML_Parser::data</A> <I>Arbitrary data which can beused by callbacks</I>
<LI><A HREF="XML_Parser.html#initial_entity">XML Parser::XML_Parser::initial_entity</A> <I>The entity we started from.</I>
<LI><A HREF="XML_Parser.html#p">XML Parser::XML_Parser::p</A> <I>The RXP parser object</I>
<LI><A HREF="XML_Parser.html#p_context">XML Parser::XML_Parser::p_context</A> <I>If context is being tracked, this is a stack of element names</I>
<LI><A HREF="XML_Parser.html#p_error_message">XML Parser::XML_Parser::p_error_message</A> <I>Last error message from the parser</I>
<LI><A HREF="XML_Parser.html#p_track_contents">XML Parser::XML_Parser::p_track_contents</A> <I>Set true when contents is being remembered.</I>
<LI><A HREF="XML_Parser.html#p_track_context">XML Parser::XML_Parser::p_track_context</A> <I>Set true when context is being remembered</I>
<LI><A HREF="XML_Parser.html#pclass">XML Parser::XML_Parser::pclass</A> <I>The class to which this parser belogs.</I>
<LI><A HREF="XML_Parser.html#source">XML Parser::XML_Parser::source</A> <I>Where we are reading from</I>
<LI><A HREF="XML_Parser_Class.html#known_ids">XML Parser::XML_Parser_Class::known_ids</A> <I>Map PUBLIC and SYSTEM IDs to places on the local system</I>
<LI><A HREF="esps_channel_names.html">esps_channel_names</A> <I>Definition of the names ESPS programs use for channels</I>
</UL>
<H2>Macros</H2>
<UL>
<LI><A HREF="EST_ChannelId.html">EST_ChannelId</A> <I>Build a number representing a channel type for a simple value such as length or voicing probability</I>
<LI><A HREF="EST_ChannelTypeCT.html">EST_ChannelTypeCT</A> <I>extract the coefficient type</I>
<LI><A HREF="EST_ChannelTypeD.html">EST_ChannelTypeD</A> <I>extract the number of differentiations</I>
<LI><A HREF="EST_ChannelTypeDecD.html">EST_ChannelTypeDecD</A> <I>integrate once</I>
<LI><A HREF="EST_ChannelTypeDelta.html">EST_ChannelTypeDelta</A> <I>differentiate N times</I>
<LI><A HREF="EST_ChannelTypeEnd.html">EST_ChannelTypeEnd</A> <I>get end from start</I>
<LI><A HREF="EST_ChannelTypeIncD.html">EST_ChannelTypeIncD</A> <I>differentiate once</I>
<LI><A HREF="EST_ChannelTypeSE.html">EST_ChannelTypeSE</A> <I>extract the start/end flag</I>
<LI><A HREF="EST_ChannelTypeStart.html">EST_ChannelTypeStart</A> <I>get start from end</I>
<LI><A HREF="EST_CoefChannelId.html">EST_CoefChannelId</A> <I>Build a number representing a channel type for a coeficient type.</I>
<LI><A HREF="EST_DiffChannelId.html">EST_DiffChannelId</A> <I>Build a number representing a channel type for a single value which can N = count starting from 0 D = Number of levels of differentiation.</I>
<LI><A HREF="EST_String.html#MAX_STRING_SIZE">EST_String::MAX_STRING_SIZE</A> <I>Maximum string size</I>
<LI><A HREF="EST_String.html#__FSF_COMPATIBILITY__">EST_String::__FSF_COMPATIBILITY__</A> <I>For better libg++ compatibility.</I>
<LI><A HREF="EST_String.html#__GRIPE_FATAL__">EST_String::__GRIPE_FATAL__</A> <I>When we find something to gripe about we die then and there</I>
<LI><A HREF="EST_String.html#__GSUB_REENTRANT__">EST_String::__GSUB_REENTRANT__</A> <I>Allow gsub() to be used in multi-threaded applications This will cause gsub to use a local table of substitution points walloced for each gsub.</I>
<LI><A HREF="EST_String.html#__STRING_ARG_GRIPE__">EST_String::__STRING_ARG_GRIPE__</A> <I>Gripe about wierd arguments like Nulls</I>
<LI><A HREF="TBUFFER_DEFAULT_SIZE.html">TBUFFER_DEFAULT_SIZE</A> <I>Initial size for buffers created with no size specified</I>
<LI><A HREF="TBUFFER_DEFAULT_STEP.html">TBUFFER_DEFAULT_STEP</A> <I>Amount to increment buffer size by</I>
<LI><A HREF="TBUFFER_N_OLD.html">TBUFFER_N_OLD</A> <I>How many chunks of memory to keep around for re-use</I>
<LI><A HREF="EST_TrackMap.html#EST_TM_REFCOUNTED">EST_TrackMap::EST_TM_REFCOUNTED</A> <I>Pass to creation function to turn on refcounting</I>
<LI><A HREF="EST_TrackMap.html#NO_SUCH_CHANNEL">EST_TrackMap::NO_SUCH_CHANNEL</A> <I>Returned if we ask for a channel not in the map</I>
<LI><A HREF="Instantiate_KVL_T.html">Instantiate_KVL_T</A> <I>Instantiate rules for list template.</I>
<LI><A HREF="Instantiate_TDEQ_T.html">Instantiate_TDEQ_T</A> <I>Instantiate rules for list template.</I>
<LI><A HREF="Instantiate_THash_T_IT_IP.html">Instantiate_THash_T_IT_IP</A> <I>Instantiate rules for hash template.</I>
<LI><A HREF="Instantiate_TIterator_T.html">Instantiate_TIterator_T</A> <I>Instantiate an iterator.</I>
<LI><A HREF="Instantiate_TList_T_MIN.html">Instantiate_TList_T_MIN</A> <I>Instantiate rules for list template.</I>
<LI><A HREF="Instantiate_TMatrix.html">Instantiate_TMatrix</A> <I>Instantiate rules for matrix template.</I>
<LI><A HREF="Instantiate_TSimpleMatrix.html">Instantiate_TSimpleMatrix</A> <I>Instantiate rules for simple-matrix template.</I>
<LI><A HREF="Instantiate_TSimpleVector.html">Instantiate_TSimpleVector</A> <I>Instantiate rules for simple-vector template.</I>
<LI><A HREF="Instantiate_TSortable_T.html">Instantiate_TSortable_T</A> <I>Instantiate rules for sortable template.</I>
<LI><A HREF="Instantiate_TStringHash_T_IT.html">Instantiate_TStringHash_T_IT</A> <I>Instantiate rules for hash template.</I>
<LI><A HREF="Instantiate_TValuedEnumI_T.html">Instantiate_TValuedEnumI_T</A> <I>Instantiate rules for named enum template.</I>
<LI><A HREF="Instantiate_TVector_T_MIN.html">Instantiate_TVector_T_MIN</A> <I>Instantiate rules for vector template.</I>
<LI><A HREF="__EST_SIGPR_FRAME_H__.html">__EST_SIGPR_FRAME_H__</A> <I>For example code, see Windowing</I>
</UL>
<H2>Enums, Unions, Structs</H2>
<UL>
<LI><A HREF="CSMM_parameter_set.html">CSMM_parameter_set</A> <I>somewhere to keep the model parameters</I>
<LI><A HREF="CSMM_set.html">CSMM_set</A> <I>somewhere to keep the models</I>
<LI><A HREF="EST_ChannelType.html">EST_ChannelType</A> <I>Symbolic names for track channels.</I>
<LI><A HREF="EST_CoefficientType.html">EST_CoefficientType</A> <I>Symbolic names for coefficient types.</I>
<LI><A HREF="EST_Server.html#Mode">EST_Server::Mode</A> <I>What type of server is this</I>
<LI><A HREF="EST_String.html#EST_chop_direction">EST_String::EST_chop_direction</A> <I>Flags indicating which bit of a string to extract</I>
<LI><A HREF="old_tbuffer.html">old_tbuffer</A> <I>Structure to remember old buffers for re-use.</I>
<LI><A HREF="EST_TTI_Entry.html">EST_TTI_Entry</A> <I>A time index for a container.</I>
<LI><A HREF="EST_TrackMap.html#ChannelMappingElement">ChannelMappingElement</A> <I>structure for the table</I>
<LI><A HREF="EST_connect_status.html">EST_connect_status</A> <I>Possible outcomes of a network connection operation </I>
<LI><A HREF="EST_error_behaviour.html">EST_error_behaviour</A> <I>Defines the attitude of a call to possible fatal errors.</I>
<LI><A HREF="EST_read_status.html">EST_read_status</A> <I>Possible outcomes of a file reading operation.</I>
<LI><A HREF="EST_rw_state.html">EST_rw_state</A> <I>State of rw </I>
<LI><A HREF="EST_write_status.html">EST_write_status</A> <I>Possible outcomes of a file writing operation </I>
<LI><A HREF="EST_THash.html#IPointer_k_s">IPointer_k_s</A> <I>A position in the table is given by a bucket number and a pointer into the bucket</I>
<LI><A HREF="EST_THash.html#IPointer_s">IPointer_s</A> <I>A position in the table is given by a bucket number and a pointer into the bucket</I>
<LI><A HREF="Safefeatureaccessfunctions..html#EST_feat_status">Non core feature funtionality.::Safe feature access functions.::EST_feat_status</A> <I>What happened when we tried to look up a value</I>
</UL>
<H2>Typedefs</H2>
<UL>
<LI><A HREF="EST_ChannelNameMap.html">EST_ChannelNameMap</A> <I>Channel name maps map textual names for track channels to symbolic names, they are just a special case of named enums</I>
<LI><A HREF="EST_ChannelNameTable.html">EST_ChannelNameTable</A> <I>Table type used to create EST_ChannelNameMaps</I>
<LI><A HREF="EST_Relation.html#Iterator">EST_Relation::Iterator</A> <I>Iteration </I>
<LI><A HREF="EST_String.html#EST_string_size">EST_String::EST_string_size</A> <I>Type of string size field</I>
<LI><A HREF="EST_TIterator.html#Iter">EST_TIterator::Iter</A> <I>Name for an itterator like this</I>
<LI><A HREF="EST_Window.html#Func">EST_Window::Func</A> <I>A function which creates a window</I>
<LI><A HREF="EST_THash.html#KeyEntries">KeyEntries</A> <I>Give the iterator a sensible name</I>
<LI><A HREF="EST_THash.html#KeyEntry">KeyEntry</A> <I>An entry returned by this iterator is just a key</I>
<LI><A HREF="EST_THash.html#Entries">Entries</A> <I>Give the iterator a sensible name</I>
<LI><A HREF="EST_THash.html#Entry">Entry</A> <I>An entry returned by the iterator is a key value pair</I>
<LI><A HREF="EST_TStringHash.html#Entries">Hash Tables::EST_TStringHash::Entries</A> <I>Give the iterator a sensible name</I>
<LI><A HREF="EST_TStringHash.html#Entry">Hash Tables::EST_TStringHash::Entry</A> <I>An entry returned by the iterator is a key value pair</I>
<LI><A HREF="KeyEntries.html">KeyEntries</A> <I>Give the iterator a sensible name</I>
<LI><A HREF="XML_Attribute_List.html">XML_Attribute_List</A> <I>Nice name for list of attribute-value pairs</I>
</UL>
<P><I><A HREF="HIER.html">Hierarchy of classes</A></I></P><HR>
<A HREF = "http://www.ed.ac.uk/">
<IMG align=right BORDER=0 SRC = "edcrest.gif"></A>
<P Align=left><I>This page is part of the
<A HREF="http://www.cstr.ed.ac.uk/projects/speech_tools.html">
Edinburgh Speech Tools Library</A> documentation
<br>
Copyright <A HREF="http://www.ed.ac.uk"> University of Edinburgh</A> 1997
<br>
Contact: <A HREF="mailto:speech_toolss@cstr.ed.ac.uk">
speech_tools@cstr.ed.ac.uk </a>
</P>
<br clear=right>
distrib
>
Fedora
>
14
>
x86_64
>
media
>
updates
>
by-pkgid
>
0e54ba0ee564ce6063a5e83aa86060c5
>
files
>
563
