#include <state.h>

Public Member Functions
	state ()
	Create a state object.
	state (std::string &, stringList &, tracks &, weights , StateFuncs )
	~state ()
	Create state from string.
size_t	getIterator ()
std::string &	getName ()
std::string &	getGFF ()
std::string &	getLabel ()
std::vector< transition * > *	getTransitions ()
std::bitset< STATE_MAX > *	getTo ()
std::bitset< STATE_MAX > *	getFrom ()
transition *	getTrans (size_t iter)
transition *	getEnding ()
emm *	getEmission (size_t iter)
double	get_emission_prob (sequences &seqs, size_t iter)
double	get_transition_prob (sequences &seqs, size_t to, size_t iter)
double	getEndTrans ()
	Get the log probability transitioning to end from the state.
void	print ()
std::string	stringify ()
bool	parse (std::string &, stringList &, tracks &, weights , StateFuncs )
void	addTransition (transition *trans)
void	setEndingTransition (transition *trans)
void	addEmission (emm *em)
void	setName (std::string &txt)
void	setGFF (std::string &txt)
	Set the GFF Tag for the state.
void	setLabel (std::string &txt)
	Set the Label for the state.
void	addToState (state *st)
	Add state that this state transitions to.
void	addFromState (state *st)
	Add state that transitions to this state.
void	setIter (size_t val)
	Set the index value to be used for the state.
bool	hasComplexEmission ()
bool	hasComplexTransition ()
bool	hasSimpleEmission ()
bool	hasSimpleTransition ()
bool	isSimple ()
void	checkLabels (std::set< std::string > &, std::set< std::string > &, std::set< std::string > &)
	Checks the label tags for traceback and combine identifiers.
void	_finalizeTransitions (std::map< std::string, state * > &state_index)

Private Member Functions
bool	_parseHeader (std::string &)
bool	_parseTransition (std::string &, stringList &, tracks &, weights , StateFuncs )
bool	_parseEmission (std::string &, stringList &, tracks &, weights , StateFuncs )

Private Attributes
std::string	name
std::string	gff
std::string	label
std::vector< transition * > *	transi
transition *	endi
std::vector< emm * >	emission
size_t	stateIterator
std::bitset< STATE_MAX >	to
std::bitset< STATE_MAX >	from

Friends
class	model

Detailed Description

Definition at line 53 of file state.h.

Constructor & Destructor Documentation

StochHMM::state::state ( )

Create a state object.

Definition at line 31 of file state.cpp.

References transi.

                :endi(NULL), stateIterator(SIZE_MAX){
        transi = new (std::nothrow) std::vector<transition*>;
    }

StochHMM::state::state	(	std::string &	txt,
		stringList &	names,
		tracks &	trcks,
		weights *	wts,
		StateFuncs *	funcs
	)

Create a state from string Parses the string to create a state

Parameters:

txt	String representation of a state
names	Names of all the states
trcks	Tracks defined for model
wts	Pointer to all weight defined for the model
funcs	State functions defined for the model

Definition at line 42 of file state.cpp.

References parse(), and transi.

                                                                                                :endi(NULL), stateIterator(SIZE_MAX){
        
        //endi=new transition(STANDARD);
        transi = new std::vector<transition*>;
        parse(txt,names,trcks, wts,funcs);
    }

StochHMM::state::~state ( )

Create state from string.

Definition at line 49 of file state.cpp.

References transi.

                 {
        delete transi;
        transi=NULL;
    }

Member Function Documentation

void StochHMM::state::_finalizeTransitions ( std::map< std::string, state * > & state_index )

Definition at line 514 of file state.cpp.

References getIterator(), StochHMM::transition::getName(), name, and transi.

Referenced by StochHMM::model::finalize().

                                                                         {
                
                //Get size # of states, but correct by -1 because
                //initial state will be kept separate.
        size_t number_of_states = state_index.size();
        std::vector<transition*>* fixed_trans = new std::vector<transition*>(number_of_states-1,NULL);
        
        //Find the proper place for the transition and put it in the correct position
        for(size_t i = 0; i < transi->size(); i++){
            transition* temp = (*transi)[i];
            std::string name = temp->getName();
            state* st = state_index[name];
                        if (st == NULL){
                                std::cerr << "State: " << name << " was declared but not defined in the model." << std::endl;
                                exit(2);
                        }
            size_t index = st->getIterator();
            (*fixed_trans)[index]=temp;
            (*transi)[i]=NULL;
        }
        
        delete transi;  //Don't need the old transition vector anymore
        transi = fixed_trans;
        return;
    }

bool StochHMM::state::_parseEmission	(	std::string &	txt,
		stringList &	names,
		tracks &	trks,
		weights *	wts,
		StateFuncs *	funcs
	)

private

Parses the emission for a state from a string

Parameters:

txt	String representation of emissions
names	stringList of all state names defined in the model
trks	Tracks defined in the model
wts	Weight defined of the model
funcs	StateFunction defined for the model

Definition at line 296 of file state.cpp.

References emission, StochHMM::emm::parse(), StochHMM::stringList::size(), and StochHMM::stringList::splitND().

Referenced by parse().

                                                                                                              {
        stringList lst;
        lst.splitND(txt,"EMISSION:");
        //lst.print();
        
        for(size_t iter=0; iter<lst.size();iter++){
            emm* temp = new(std::nothrow) emm;
            
            if (temp==NULL){
                std::cerr << "OUT OF MEMORY\nFile" << __FILE__ << "Line:\t"<< __LINE__ << std::endl;
                exit(1);
            }
            
            if (!temp->parse(lst[iter],trks,wts,funcs)){
                return false;
            }
            emission.push_back(temp);
        }
        
        return true;
    }

bool StochHMM::state::_parseHeader ( std::string & txt )

private

Parse the state header information and assign to class variables *Required header information includes then NAME and PATH_LABEL *Optonal header information includes GFF_DESC

Parameters:

txt	String representation of state header

Definition at line 127 of file state.cpp.

References StochHMM::clear_whitespace(), StochHMM::stringList::contains(), gff, StochHMM::stringList::indexOf(), label, name, StochHMM::stringList::size(), and StochHMM::splitString().

Referenced by parse().

                                          {
        
        clear_whitespace(txt,"\t ");
        stringList lst = splitString(txt,"\n:");
        
        size_t idx;
        
        //parse NAME  (REQUIRED)
        if (lst.contains("NAME")){
            idx= lst.indexOf("NAME");
            if (idx+1 < lst.size()){
                idx++;
                name=lst[idx];
            }
            else{
                std::cerr << "The states NAME couldn't be parsed from " << txt << std::endl;
                return false;
            }
            
            
            if (name.compare("INIT")==0){
                return true;
            }
        }
        else{
            std::cerr << "No NAME found in state header information. Please check formatting. Following is header information recieved: " << txt << std::endl;
            return false;
        }
        
        //parse PATH_LABEL  (REQUIRED)
        if (lst.contains("PATH")){
            idx= lst.indexOf("PATH");
            if (idx+1 < lst.size()){
                idx++;
                label=lst[idx];
            }
            else{
                std::cerr <<  "The states PATH_LABEL couldn't be parsed from " << txt << std::endl;
                return false;
            }
            
        }
        else{
            std::cerr << "No PATH_LABEL found in state header information. Please check formatting. Following is header information recieved: " << txt << std::endl;
            return false;
        }
        
        //Parse GFF_DESC  (Optional)
        if (lst.contains("GFF")){
            idx= lst.indexOf("GFF");
            if (idx+1 < lst.size()){
                idx++;
                gff=lst[idx];
            }
            else{
                std::cerr <<  "The states GFF_DESC couldn't be parsed from " << txt << std::endl;
                return false;
            }
        }
                
        return true;
    }

bool StochHMM::state::_parseTransition	(	std::string &	txt,
		stringList &	names,
		tracks &	trks,
		weights *	wts,
		StateFuncs *	funcs
	)

private

Parses the transitions of the state from a text string

Parameters:

txt	Text representation of the transitions
name	StringList of all state names defined in the model
trks	Reference to tracks for the model
wts	Weight defined in the model
funcs	State functions defined for the model

Definition at line 197 of file state.cpp.

References addTransition(), StochHMM::clear_whitespace(), StochHMM::stringList::contains(), StochHMM::COUNTS, StochHMM::DURATION, endi, StochHMM::transition::getName(), StochHMM::LEXICAL, StochHMM::LOG_PROB, StochHMM::transition::parse(), StochHMM::PROBABILITY, StochHMM::stringList::removeComments(), StochHMM::stringList::removeLWS(), StochHMM::stringList::size(), StochHMM::stringList::splitND(), StochHMM::splitString(), and StochHMM::STANDARD.

Referenced by parse().

                                                                                                                {
        //SPLIT UP TRANSITIONS AND APPLY SEPARATELY
        stringList lst;
        lst.splitND(txt,"TRANSITION:");
        
        
        for(size_t iter=0;iter<lst.size();iter++){
            
            stringList line=splitString(lst[iter],"\n");
            line.removeLWS("\t ");
            line.removeComments();
            //Line 1 defines transition type
            
            clear_whitespace(line[0],"\t");
            stringList head=splitString(line[0],":");
            
            //DETERMINE TYPE
            transType tp;
            if (head.contains("STANDARD")){tp=STANDARD;}
            else if (head.contains("DURATION")){tp=DURATION;}
            else if (head.contains("LEXICAL")){tp=LEXICAL;}
            else{
                std::cerr << "Unrecognized Transition type(STANDARD, DURATION, LEXICAL):" << txt << std::endl;
                return false;
                //Error not recognized transition type
            }
            
            //DETERMINE VALUE TYPE
            valueType valtyp;
            if (head.contains("P(X)")){valtyp=PROBABILITY;}
            else if (head.contains("LOG")){valtyp=LOG_PROB;}
            else if (head.contains("COUNTS")){valtyp=COUNTS;}
            else {
                std::cerr << "Unrecognized Transition value type( P(X), LOG, COUNTS): " << txt << std::endl;
                return false;
                //Error not recognized value type
            }
            
            
            
            if (tp==STANDARD){
                //Process each following from line
                for(size_t iter=1;iter<line.size();iter++){
                    transition* temp = new(std::nothrow) transition(tp);
                    
                    if (temp==NULL){
                        std::cerr << "OUT OF MEMORY\nFile" << __FILE__ << "Line:\t"<< __LINE__ << std::endl;
                        exit(1);
                    }
                    
                    if (!temp->parse(line[iter], names, valtyp, trks, wts, funcs)){
                        std::cerr << "Couldn't parse Transition " << std::endl;
                    }
                    
                    std::string transName = temp->getName();
                    
                    if (transName=="END"){
                        endi = temp;
                    }
                    else{
                        //size_t idx = names.indexOf(transName);
                        //idx--;
                        addTransition(temp);
                    }
                }
                
            }
                        
            else if (tp==DURATION || tp==LEXICAL ){
                transition* temp = new(std::nothrow) transition(tp);
                
                if (temp==NULL){
                    std::cerr << "OUT OF MEMORY\nFile" << __FILE__ << "Line:\t"<< __LINE__ << std::endl;
                    exit(1);
                }
                
                if (!temp->parse(line,names,valtyp,trks,wts,funcs)){
                    std::cerr << "Couldn't parse Transition "<< std::endl;
                    return false;
                }
                std::string transName = temp->getName();
                
                
                //size_t idx = names.indexOf(transName);
                //idx--;
                addTransition(temp);
            }
        }
        return true;
    }

void StochHMM::state::addEmission ( emm * em )

inline

Add emission to the state

Parameters:

em	Pointer to the emission to be added

Definition at line 131 of file state.h.

References emission.

{emission.push_back(em);};

void StochHMM::state::addFromState ( state * st )

inline

Add state that transitions to this state.

Definition at line 147 of file state.h.

References from, and getIterator().

Referenced by StochHMM::model::_addStateToFromTransition().

{from[st->getIterator()]=1;};

void StochHMM::state::addToState ( state * st )

inline

Add state that this state transitions to.

Definition at line 144 of file state.h.

References getIterator(), and to.

Referenced by StochHMM::model::_addStateToFromTransition().

{to[st->getIterator()]=1;};

void StochHMM::state::addTransition ( transition * trans )

inline

Add the transition to the state

Parameters:

trans Pointer to transition to add to the state

Definition at line 123 of file state.h.

References transi.

Referenced by _parseTransition().

{transi->push_back(trans);};

void StochHMM::state::checkLabels	(	std::set< std::string > &	labels,
		std::set< std::string > &	gff,
		std::set< std::string > &	name
	)

Checks the label tags for traceback and combine identifiers.

Definition at line 451 of file state.cpp.

References StochHMM::DIFF_STATE, StochHMM::FULL, StochHMM::transitionFuncParam::getCombineName(), StochHMM::transitionFuncParam::getCombineType(), StochHMM::transitionFuncParam::getTracebackName(), StochHMM::transitionFuncParam::getTracebackType(), StochHMM::START_INIT, StochHMM::STATE_GFF, StochHMM::STATE_LABEL, StochHMM::STATE_NAME, StochHMM::STATEGFF, StochHMM::STATELABEL, and StochHMM::STATENAME.

                                                                                                     {
        for(size_t i = 0;i<(*transi).size();i++){
            transitionFuncParam* func = (*transi)[i]->getExtFunction();
            if (func!=NULL){
                
                tracebackIdentifier tt = func->getTracebackType();
                std::string tn = func->getTracebackName();
                
                //Traceback Identifier
                if (tt != START_INIT && tt != DIFF_STATE){
                    if (tt == STATE_NAME){
                        if (!name.count(tn)){
                            std::cerr << "Model Function or Distribution traceback definition contains Unknown State Name:\t" << tn << std::endl;
                        }
                    }
                    else if (tt == STATE_GFF){
                        if (!gff.count(tn)){
                            std::cerr << "Model function or distribution traceback definition contains Unknown GFF Descrition:\t" << tn << std::endl;
                        }
                    }
                    else if (tt == STATE_LABEL){
                        if (!labels.count(tn)){
                            std::cerr << "Model function or distribution traceback definition contains Unknown Path Label:\t" << tn << std::endl;
                        }
                    }
                }
                
                
                combineIdentifier ct = func->getCombineType();
                std::string cn = func->getCombineName();
                
                //Combine Identifiers
                if (ct != FULL){
                    if (ct == STATENAME){
                        if (!name.count(cn)){
                            std::cerr << "Traceback Combine definition contains Unknown State Name:\t" << cn << std::endl;
                        }
                    }
                    else if (ct == STATEGFF){
                        if (!gff.count(cn)){
                            std::cerr << "Traceback Combine definition contains Unknown GFF Descrition:\t" << cn << std::endl;
                        }
                    }
                    else if (ct == STATELABEL){
                        if (!labels.count(cn)){
                            std::cerr << "Traceback Combine definition contains Unknown Path Label:\t" << cn << std::endl;
                        }
                    }
                }
                                
            }
        }
        
        return;
    }

double StochHMM::state::get_emission_prob	(	sequences &	seqs,
		size_t	iter
	)

Get the emission value from a state at a particular position in the sequence

Parameters:

seqs	Sequences the model is analyzing
iter	Position in the sequence

Definition at line 411 of file state.cpp.

References emission.

Referenced by StochHMM::trellis::naive_forward(), StochHMM::trellis::naive_nth_viterbi(), StochHMM::trellis::naive_stochastic_forward(), StochHMM::trellis::naive_stochastic_viterbi(), StochHMM::trellis::naive_viterbi(), StochHMM::trellis::simple_backward(), and StochHMM::trellis::simple_posterior().

                                                               {
        double value(emission[0]->get_emission(seqs,iter));
        for(size_t i=1;i<emission.size();i++){
            value+=emission[i]->get_emission(seqs,iter);  //Pass sequences type to get_emission for each emission in the state
        }
        return value;
    }

double StochHMM::state::get_transition_prob	(	sequences &	seqs,
		size_t	to,
		size_t	iter
	)

Get the transition value from a state at a particular position in the sequence

Parameters:

seqs	Sequences the model is analyzing
to	State that transition is being calculated to
iter	Position in the sequence

Definition at line 424 of file state.cpp.

References StochHMM::STANDARD, to, and transi.

                                                                            {
        double value;
        
        if ((*transi)[to]==NULL){
            return -INFINITY;
        }
        else if ((*transi)[to]->transition_type==STANDARD){
            value = (*transi)[to]->log_trans;
        }
        else{
            std::cerr << "Need to implement this functionality" <<std::endl;
            value = (*transi)[to]->getTransition(iter,&seqs);
            
        }
        return value;
    }

emm* StochHMM::state::getEmission ( size_t iter )

inline

Get the emission defined at index

Parameters:

iter	Index of emm to get emm* pointer to emission

Definition at line 109 of file state.h.

References emission.

{return emission[iter];};

transition* StochHMM::state::getEnding ( )

inline

Get the ending transition

Returns:: transition* Pointer to ending transition not defined return value should be NULL

Definition at line 104 of file state.h.

References endi.

{return endi;};

double StochHMM::state::getEndTrans ( )

Get the log probability transitioning to end from the state.

Definition at line 442 of file state.cpp.

References endi, and StochHMM::transition::log_trans.

                             {
        if (endi==NULL){
            return -INFINITY;
        }
        return endi->log_trans;
    }

std::bitset<STATE_MAX>* StochHMM::state::getFrom ( )

inline

Get all states that transition to this state

Returns:: std::vector<state*>* Pointer to all state that transition to this state

Definition at line 92 of file state.h.

References from.

{return &from;};

std::string& StochHMM::state::getGFF ( )

inline

Get the GFF tag to use for the state std::string GFF tag

Definition at line 74 of file state.h.

References gff.

Referenced by StochHMM::trellis::get_explicit_duration_length(), StochHMM::traceback_path::gff(), StochHMM::traceback_path::print_gff(), and StochHMM::trellis::transitionFuncTraceback().

{return gff;};

size_t StochHMM::state::getIterator ( )

inline

Get the states integer index value

Returns:: integer

Definition at line 66 of file state.h.

References stateIterator.

Referenced by _finalizeTransitions(), addFromState(), addToState(), StochHMM::trellis::get_explicit_duration_length(), StochHMM::trellis::getTransition(), and StochHMM::trellis::transitionFuncTraceback().

{return stateIterator;};

std::string& StochHMM::state::getLabel ( )

inline

Get the Label used for the state

Returns:: std::string

Definition at line 78 of file state.h.

References label.

Referenced by StochHMM::trellis::get_explicit_duration_length(), StochHMM::traceback_path::label(), StochHMM::traceback_path::print_label(), and StochHMM::trellis::transitionFuncTraceback().

{return label;};

std::string& StochHMM::state::getName ( )

inline

Get the name of the state

Returns:: std::string Name of state

Definition at line 70 of file state.h.

References name.

Referenced by StochHMM::model::_parseStates(), StochHMM::model::addState(), StochHMM::trellis::get_explicit_duration_length(), StochHMM::traceback_path::name(), and StochHMM::trellis::transitionFuncTraceback().

{return name;};

std::bitset<STATE_MAX>* StochHMM::state::getTo ( )

inline

Get all states that this state has transitions to

Returns:: std::vector<state*>* Pointer to all state that are transitioned to

Definition at line 86 of file state.h.

References to.

{return &to;};

transition* StochHMM::state::getTrans ( size_t iter )

inline

Get transition at index

Parameters:

iter	Index to get transition for

Returns:: transition* pointer to the transition

Definition at line 99 of file state.h.

References transi.

Referenced by StochHMM::trellis::getTransition().

{return (*transi)[iter];};

std::vector<transition*>* StochHMM::state::getTransitions ( )

inline

Get all transition defined for the state

Returns:: std::vector<transitions*>* Pointer to all transitions in state

Definition at line 82 of file state.h.

References transi.

Referenced by StochHMM::model::_addStateToFromTransition().

{return transi;};

bool StochHMM::state::hasComplexEmission ( )

Definition at line 541 of file state.cpp.

References emission.

Referenced by isSimple().

                                      {
                for(size_t i=0; i < emission.size() ; ++i){
                        if (emission[i]->isComplex()){
                                return true;
                        }
                }
                return false;
        }

bool StochHMM::state::hasComplexTransition ( )

Definition at line 552 of file state.cpp.

References transi.

Referenced by isSimple().

                                        {
                for(size_t i=0;i<(*transi).size();++i){
                        
                        if ((*transi)[i]==NULL){
                                continue;
                        }
                        
                        if ((*transi)[i]->isComplex()){
                                return true;
                        }
                }
                return false;
        }

bool StochHMM::state::hasSimpleEmission ( )

bool StochHMM::state::hasSimpleTransition ( )

bool StochHMM::state::isSimple ( )

Definition at line 566 of file state.cpp.

References hasComplexEmission(), and hasComplexTransition().

                            {
                if (!hasComplexEmission() && ! hasComplexTransition()){
                        return true;
                }
                return false;
        }

bool StochHMM::state::parse	(	std::string &	txt,
		stringList &	names,
		tracks &	trks,
		weights *	wts,
		StateFuncs *	funcs
	)

Parses state from string

Parameters:

txt	String of state definition
names	StringList with names of other states. Used to identify position of transitions in transition In future, may want to organize transitions in non-linear fashion

Definition at line 73 of file state.cpp.

References _parseEmission(), _parseHeader(), _parseTransition(), and name.

Referenced by StochHMM::model::_parseStates(), and state().

                                                                                                    {
        size_t stateHeaderInfo = txt.find("STATE:");
        size_t transitionsInfo = txt.find("TRANSITION:");
        size_t emissionInfo    = txt.find("EMISSION:");
        stringList lines;
        
        if (stateHeaderInfo==std::string::npos){
            std::cerr << "Couldn't identify state Header Information. Please check the formatting.  The supplied text was : " << txt << std::endl;
            return false;
        }
        
        if (transitionsInfo == std::string::npos){
            std::cerr << "Couldn't identify state Transitions Information.  Please check the formatting.  The supplied text was : " << txt << std::endl;
            return false;
        }
        
        //Extract and Parse Header Information
        std::string header = txt.substr(stateHeaderInfo,transitionsInfo-stateHeaderInfo);
        if (!_parseHeader(header)){
            return false;
        }
                
        
        //Extract and Parse Transition Information
        std::string trans = (emissionInfo==std::string::npos) ? txt.substr(transitionsInfo) : txt.substr(transitionsInfo, emissionInfo - transitionsInfo);
        //std::cout << trans << std::endl;
        if (!_parseTransition(trans, names, trks, wts, funcs)){
            return false;
        }
        
        
        //Check emissions existence  (only INIT state can have no emission)
        if (emissionInfo != std::string::npos){
            std::string emmis = txt.substr(emissionInfo);
            if (!_parseEmission(emmis, names, trks, wts, funcs)){
                std::cerr << "Couldn't parse the emissions for state: " << name << std::endl;
                return false;
            }
        }
        else{
            //Check name is INIT.   Only INIT state can not have an emission
            if (name.compare("INIT")!=0){
                std::cerr << "No emission defined for State: " << name << std::endl;
                return false;
            }
        }
        
        return true;
    }

void StochHMM::state::print ( )

Definition at line 319 of file state.cpp.

References stringify().

                     {
        std::cout<< stringify() << std::endl;
    }

void StochHMM::state::setEndingTransition ( transition * trans )

inline

Set the ending transition to a given transition

Parameters:

trans Pointer to transition to be used as ending transition

Definition at line 127 of file state.h.

References endi.

{endi=trans;};

void StochHMM::state::setGFF ( std::string & txt )

inline

Set the GFF Tag for the state.

Definition at line 138 of file state.h.

References gff.

{gff=txt;};

void StochHMM::state::setIter ( size_t val )

inline

Set the index value to be used for the state.

Definition at line 150 of file state.h.

References stateIterator.

{stateIterator=val;};

void StochHMM::state::setLabel ( std::string & txt )

inline

Set the Label for the state.

Definition at line 141 of file state.h.

References label.

{label=txt;};

void StochHMM::state::setName ( std::string & txt )

inline

Set the name of the state

Parameters:

txt	Name of the state

Definition at line 135 of file state.h.

References name.

{name=txt;};

std::string StochHMM::state::stringify ( )

Returns:: std::string

Definition at line 326 of file state.cpp.

References StochHMM::DURATION, emission, endi, gff, label, StochHMM::LEXICAL, name, StochHMM::STANDARD, StochHMM::transition::stringify(), and transi.

Referenced by StochHMM::model::_stringifyStates(), and print().

                              {
        std::string stateString;
        stateString+="STATE:\n";
        stateString+="\tNAME:\t" + name + "\n";
        
        if (name.compare("INIT")!=0){
            if (!gff.empty()){ stateString+="\tGFF_DESC:\t" + gff + "\n";}
            stateString+="\tPATH_LABEL:\t" + label + "\n";
        }
        
        std::string standardString;
        std::string distribString;
        std::string lexicalString;
        
        //Get Transitions Standard, Distribution, Lexical
        for(size_t i=0;i<transi->size();i++){
            if ((*transi)[i]==NULL){ continue;}
            
            transType tp = (*transi)[i]->getTransitionType();
            if (tp == STANDARD){
                if (standardString.empty()){
                    standardString+="TRANSITION:\tSTANDARD:\tLOG\n";
                }
                standardString+=(*transi)[i]->stringify() + "\n";
            }
            else if (tp == DURATION){
                distribString+="TRANSITION:\tDURATION:\tLOG\n";
                distribString+=(*transi)[i]->stringify();
                
            }
            else if (tp == LEXICAL){
                if ((*transi)[i]->LexFunctionDefined()){
                    lexicalString+="TRANSITION:\tLEXICAL:\tFUNCTION:\t";
                    lexicalString+=(*transi)[i]->getLexicalFunctionName();
                    lexicalString+="\n";
                }
                else{
                    lexicalString+="TRANSITION:\tLEXICAL:\tLOG\n";
                    lexicalString+=(*transi)[i]->stringify();
                }
                
            }
        }
        
        
        //Process Transition to Ending;
        if (endi!=NULL){
            if (standardString.empty()){
                standardString+="TRANSITIONS:\tSTANDARD:\tLOG\n";
            }
            standardString+=endi->stringify();
        }
        
        
        if (name.compare("INIT")==0){
            stateString+=standardString + "\n\n";
            return stateString;
        }
        else{
            if (!standardString.empty()){
                stateString+=standardString + "\n";
            }
            
            if (!distribString.empty()){
                stateString+=distribString + "\n";
            }
            
            if (!lexicalString.empty()){
                stateString+=lexicalString + "\n";
            }
        }
        
        
        
        //Print Emissions
        for(size_t i=0;i<emission.size();i++){
            stateString+=emission[i]->stringify();
        }
        
        return stateString;
    }