ghmm_state.cpp

一个通用的隐性马尔可夫C代码库 开发环境:C语言 简要说明:这是一个通用的隐性马尔可夫C代码库

}

void GHMM_State::fillState(sdstate* s) {
  fprintf(stderr, "GHMM_State::fillState. You should not be here\n");
  exit(1);
}

void GHMM_State::XMLIO_finishedReading() {
  if (!demission && !cemission) {
    fprintf(stderr,"state with id='%s' lacks emission element.\n",id.c_str());
    exit(1);
  }
}


void GHMM_State::changeOutEdge(int target, double prob) {
  changeOutEdge(0,target,prob);
}


void GHMM_State::changeInEdge(int target, double prob) {
  changeInEdge(0,target,prob);
}


void GHMM_State::changeOutEdge(int matrix_index, int target, double prob) {
  if (prob == 0) {
    removeOutEdge(target);
    return;
  }
  
  int i;
  if (c_sstate) {
    for (i = 0; i < c_sstate->out_states; ++i) {
      if (c_sstate->out_id[i] == target) {
	c_sstate->out_a[matrix_index][i] = prob;
	return;
      }
    }

    /* create new state. */
    c_sstate->out_states += 1;
    c_sstate->out_id = (int*) realloc(c_sstate->out_id,sizeof(int) * c_sstate->out_states);
    c_sstate->out_id[c_sstate->out_states - 1] = target;

    for (i = 0; i < parent_model->getNumberOfTransitionMatrices(); ++i) {
      c_sstate->out_a[i] = (double*) realloc(c_sstate->out_a[i],sizeof(double) * c_sstate->out_states);
      c_sstate->out_a[i][c_sstate->out_states - 1]  = 0;
    }
    c_sstate->out_a[matrix_index][c_sstate->out_states - 1]  = prob;
  }

  if (c_state) {
    for (i = 0; i < c_state->out_states; ++i)
      if (c_state->out_id[i] == target) {
	c_state->out_a[i] = prob;
	return;
      }

    /* create new state. */
    c_state->out_states += 1;
    c_state->out_id = (int*) realloc(c_state->out_id,sizeof(int) * c_state->out_states);
    c_state->out_id[c_state->out_states - 1] = target;
    
    c_state->out_a = (double*) realloc(c_state->out_a,sizeof(double) * c_state->out_states);
    c_state->out_a[c_state->out_states - 1] = prob;
  }
}


void GHMM_State::removeOutEdge(int target) {
  int i;

  if (c_sstate)
    for (i = 0; i < c_sstate->out_states; ++i)
      if (c_sstate->out_id[i] == target) {
	c_sstate->out_id[i] = c_sstate->out_id[c_sstate->out_states - 1];
	for (int m = 0; m < parent_model->getNumberOfTransitionMatrices(); ++m)
	  c_sstate->out_a[m][i]  = c_sstate->out_a[m][c_sstate->out_states - 1];
	c_sstate->out_states -= 1;
	return;
      }

  if (c_state)
    for (i = 0; i < c_state->out_states; ++i)
      if (c_state->out_id[i] == target) {
	c_state->out_id[i] = c_state->out_id[c_state->out_states - 1];
	c_state->out_a[i]  = c_state->out_a[c_state->out_states - 1];
	c_state->out_states -= 1;
	return;
      }
}


void GHMM_State::removeInEdge(int source) {
  int i;

  if (c_sstate)
    for (i = 0; i < c_sstate->in_states; ++i)
      if (c_sstate->in_id[i] == source) {
	c_sstate->in_id[i] = c_sstate->in_id[c_sstate->in_states - 1];
	for (int m = 0; m < parent_model->getNumberOfTransitionMatrices(); ++m)
	  c_sstate->in_a[m][i]  = c_sstate->in_a[m][c_sstate->in_states - 1];
	c_sstate->in_states -= 1;
	return;
      }

  if (c_state)
    for (i = 0; i < c_state->in_states; ++i)
      if (c_state->in_id[i] == source) {
	c_state->in_id[i] = c_state->in_id[c_state->in_states - 1];
	c_state->in_a[i]  = c_state->in_a[c_state->in_states - 1];
	c_state->in_states -= 1;
	return;
      }
}


void GHMM_State::changeInEdge(int matrix_index, int source, double prob) {
  if (prob == 0) {
    removeInEdge(source);
    return;
  }
  
  int i;
  if (c_sstate) {
    for (i = 0; i < c_sstate->in_states; ++i)
      if (c_sstate->in_id[i] == source) {
	c_sstate->in_a[matrix_index][i] = prob;
	return;
      }
    
    /* create new state. */
    c_sstate->in_states += 1;
    c_sstate->in_id = (int*) realloc(c_sstate->in_id,sizeof(int) * c_sstate->in_states);
    c_sstate->in_id[c_sstate->in_states - 1] = source;
    
    for (i = 0; i < parent_model->getNumberOfTransitionMatrices(); ++i) {
      c_sstate->in_a[i] = (double*) realloc(c_sstate->in_a[i],sizeof(double) * c_sstate->in_states);
      c_sstate->in_a[i][c_sstate->in_states - 1]  = 0;
    }
    c_sstate->in_a[matrix_index][c_sstate->in_states - 1]  = prob;
  }

  if (c_state) {
    for (i = 0; i < c_state->in_states; ++i)
      if (c_state->in_id[i] == source) {
	c_state->in_a[i] = prob;
	return;
      }
    
    /* create new state. */
    c_state->in_states += 1;
    c_state->in_id = (int*) realloc(c_state->in_id,sizeof(int) * c_state->in_states);
    c_state->in_id[c_state->in_states - 1] = source;
    
    c_state->in_a = (double*) realloc(c_state->in_a,sizeof(double) * c_state->in_states);
    c_state->in_a[c_state->in_states - 1] = prob;
  }
}


void GHMM_State::setOutputProbability(int index, double prob) {
  if (!c_state) {
    fprintf(stderr,"GHMM_State::setOutputProbability(int,double): object does not contain state.\n");
    exit(1);
  }
   
  GHMM_DiscreteModel* m = (GHMM_DiscreteModel*) parent_model;
  if (index >= m->c_model->M) {
    fprintf(stderr,"GHMM_State::setOutputProbability(int,double): symbol No. %d requested, but maximum number is %d.\n",index,m->c_model->M - 1);
    exit(1);
  }

  c_state->b[index] = prob;
}


void GHMM_State::setOutputProbability(const string& id, double prob) {
  setOutputProbability(((GHMM_DiscreteModel*)(parent_model))->alphabet->getIndex(id),prob);
}


void GHMM_State::setInitialProbability(double prob) {
  if (c_state)
    c_state->pi = prob;

  if (c_sstate)
    c_sstate->pi = prob;
}


XMLIO_Attributes& GHMM_State::XMLIO_getAttributes() {
  attributes["id"] = id;

  return attributes;
}


const int GHMM_State::XMLIO_writeContent(XMLIO_Document& writer) {
  int total_bytes = 0;
  int result;
  
  double initial = getInitial();

  writer.changeIndent(2);

  //  if (initial > 0) {
  result = writer.writeEndlIndent();
  
  if (result < 0)
    return result;
  total_bytes += result;
  
  result = writer.writef("<initial>%f</initial>",initial);
  
  if (result < 0)
    return result;
  total_bytes += result;
  //  }

  /* write emission */
  result = writer.writeEndl();
  
  if (result < 0)
    return result;
  total_bytes += result;
  
  if (getModelType() == GHMM_CONTINOUS) {
    GHMM_CEmission* my_emission = new GHMM_CEmission(this);
    result = writer.writeElement(my_emission);
    SAFE_DELETE(my_emission);
  }

  if (getModelType() == GHMM_DISCRETE) {
    GHMM_DEmission* my_emission = new GHMM_DEmission(this);
    result = writer.writeElement(my_emission);
    SAFE_DELETE(my_emission);
  }

  if (result < 0)
    return result;
  total_bytes += result;
  /* end write emission */

  result = writer.writeEndl();

  if (result < 0)
    return result;
  total_bytes += result;

  return total_bytes;
}


double GHMM_State::getInitial() const {
  if (c_sstate)
    return c_sstate->pi;

  if (c_state)
    return c_state->pi;

  fprintf(stderr,"%s::getInitial() state is empty\n",toString());
  exit(1);

  return 0;
}


GHMM_Transition* GHMM_State::createTransition(int edge_index) {
  if (c_state)
    return new GHMM_Transition(this,parent_model->getState(c_state->out_id[edge_index]),c_state->out_a[edge_index]);

  if (c_sstate)
    return new GHMM_Transition(this,parent_model->getState(c_sstate->out_id[edge_index]),c_sstate->out_a[0][edge_index]);

  return NULL;
}


void GHMM_State::setID(const string& my_id) {
  parent_model->stateIDChanged(id,my_id);

  id               = my_id;
  attributes["id"] = my_id;
}


GHMM_AbstractModel* GHMM_State::getModel() const {
  return parent_model;
}


int GHMM_State::getOutEdges() const {
  if (c_sstate)
    return c_sstate->out_states;

  if (c_state)
    return c_state->out_states;

  return 0;
}


GHMM_ModelType GHMM_State::getModelType() const {
  return getModel()->getModelType();
}