edu.berkeley.nlp.syntax.StateSet Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of berkeleyparser Show documentation
The Berkeley parser analyzes the grammatical structure of natural language using probabilistic context-free grammars (PCFGs).
The newest version!
package edu.berkeley.nlp.syntax;

import java.text.NumberFormat;

import edu.berkeley.nlp.math.DoubleArrays;
import edu.berkeley.nlp.util.Numberer;
import edu.berkeley.nlp.util.ScalingTools;

/**
 * Represent parsetrees, with each node consisting of a label and a list of children.
 * The score tables are not allocated by the constructor and allocate() and deallocate()
 * must be called manually. This is to allow more control over memory usage.
 * @author Slav Petrov
 * @author Romain Thibaux
 */
public class StateSet {
  public static final double SCALE = Math.exp(100);

  double[] iScores;     // the log-probabilities for each sublabels
  double[] oScores;
  int iScale;
  int oScale;
  String word; /** the word of this node, if it is a terminal node; else null*/
  public int wordIndex, sigIndex;
  
  short numSubStates;
  short state;
  public short from, to;
  
  
  // Run allocate() before any other operation
  public void allocate() {
    iScores = new double[numSubStates];
    oScores = new double[numSubStates];
  }
  
  // run deallocate() if the scores are no longer needed and
  // this object will not be used for a long time
  public void deallocate() {
    iScores = null;
    oScores = null;
  }
  
  @Override
	public String toString(){
    if (word!=null) return word+" "+from+"-"+to;// + " " + substates.length;
    String s = Numberer.getGlobalNumberer("tags").object(state)+" ";//"[";
//    for (int i = 0; i < numSubStates; i++){
//      NumberFormat f = NumberFormat.getInstance();
//      f.setMaximumFractionDigits(5);
//      String iS = "";
//      String oS = "";
//      if (iScores != null && iScores[i]!=0)
//      	iS = ": iS="+f.format(iScores[i]);//Math.log(iScores[i])+100*iScale);
//      if (oScores != null && oScores[i]!=0) 
//      	oS = " oS="+f.format(oScores[i]);//Math.log(oScores[i])+100*oScale);
////      String iS = Double.toString(Math.log(iScores[i])+100*iScale);
////      String oS = Double.toString(Math.log(oScores[i])+100*oScale);
////    	String iS = "";
////    	String oS = "";
//    	if (iScores != null && DoubleArrays.max(iScores)==0) iS = ", iS=0";
//    	if (oScores != null && DoubleArrays.max(oScores)==0) oS = ", oS=0";
//      s=s.concat(" ["+state+"-"+i+iS+oS+"]");
//    }
//    s=s.concat(" ]");
    return s;
  }
  
  public final short getState(){
    return state;
  }
  
  public final double getIScore(int i){
    return iScores[i];
  }
  
  public final double[] getIScores() {
  	return iScores;
  }

  public final double getOScore(int i){
    return oScores[i];
  }

  public final double[] getOScores() {
  	return oScores;
  }

  public final void setIScores(double[] s) {
    iScores = s;
  }

  public final void setIScore(int i, double s) {
  	if (iScores == null) iScores = new double[numSubStates];
  	iScores[i] = s;
  }
  
  public final void setOScores(double[] s) {
    oScores = s;
  }

  public final void setOScore(int i, double s) {
    if (oScores == null) oScores = new double[numSubStates];
  	oScores[i] = s;
  }

/*  public void logAddIScore(short i, double s) {
    iScores[i] = SloppyMath.logAdd(iScores[i], s);
  }

  public void logAddOScore(short i,double s) {
    oScores[i] = SloppyMath.logAdd(oScores[i], s);
  }
*/
  
  public final int numSubStates() {
    return numSubStates;
  }
  /*
  public StateSet(int nSubStates) {
    this.numSubStates = nSubStates;
    this.iScores = new double[nSubStates];
    this.oScores = new double[nSubStates];
    for ( int i = 0; i < nSubStates; i++ ) {
      iScores[i] = Double.NEGATIVE_INFINITY;
      oScores[i] = Double.NEGATIVE_INFINITY;
    }
  }*/

  public StateSet(short state, short nSubStates) {
    this.numSubStates = nSubStates;
    this.state = state;
  }
    
  public StateSet(short s, short nSubStates, String word, short from, short to) {
    this.numSubStates = nSubStates;
    this.state = s;
    this.word = word;
    this.from = from;
    this.to = to;
    
  }
  
  public StateSet(StateSet oldS, short nSubStates) {
    this.numSubStates = nSubStates;
    this.state = oldS.state;
    this.word = oldS.word;
    this.from = oldS.from;
    this.to = oldS.to;
    
  }
  
  public String getWord() {
    return word;
  }

  
  public void setWord(String word) {
    this.word = word;
  }

  public void scaleIScores(int previousScale){
  	iScale = ScalingTools.scaleArray(iScores, previousScale);
//	  int logScale = 0;
//	  double scale = 1.0;
//	  double max = ArrayMath.max(iScores);
//	  //if (max==0) 	System.out.println("All iScores are 0!");
//	  if (SloppyMath.isVeryDangerous(max)) return;
//	  while (max > SCALE) {
//	    max /= SCALE;
//	    scale *= SCALE;
//	    logScale += 1;
//	  }
//	  while (max > 0.0 && max < 1.0 / SCALE) {
//	    max *= SCALE;
//	    scale /= SCALE;
//	    logScale -= 1;
//	  }
//	  if (logScale != 0) {
//	    for (int i = 0; i < numSubStates; i++) {
//	      iScores[i] /= scale;
//	    }
//	  }
//	  if ((max!=0) && ArrayMath.max(iScores)==0){
//	  	System.out.println("Undeflow when scaling iScores!");
//	  }
//	  iScale = previousScale + logScale;
  }

  public void scaleOScores(int previousScale){
  	oScale = ScalingTools.scaleArray(oScores, previousScale);
  	//	  int logScale = 0;
//	  double scale = 1.0;
//	  double max = ArrayMath.max(oScores);
//	  if (SloppyMath.isVeryDangerous(max)) return;
//	  //if (max==0) 	System.out.println("All oScores are 0!");
//	  while (max > SCALE) {
//	    max /= SCALE;
//	    scale *= SCALE;
//	    logScale += 1;
//	  }
//	  while (max > 0.0 && max < 1.0 / SCALE) {
//	    max *= SCALE;
//	    scale /= SCALE;
//	    logScale -= 1;
//	  }
//	  if (logScale != 0) {
//	    for (int i = 0; i < numSubStates; i++) {
//	      oScores[i] /= scale;
//	    }
//	  }
//	  if ((max!=0) && ArrayMath.max(oScores)==0){
//	  	System.out.println("Undeflow when scaling oScores!");
//	  }
//	  oScale = previousScale + logScale;
  }

  public int getIScale() {
		return iScale;
	}

	public void setIScale(int scale) {
		iScale = scale;
	}

	public int getOScale() {
		return oScale;
	}

	public void setOScale(int scale) {
		oScale = scale;
	}

	/**
	 * @return
	 */
	public StateSet copy() {
		return new StateSet(this, this.numSubStates);
	}
}