edu.berkeley.nlp.util.ScalingTools 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.util;

import java.util.Arrays;

import edu.berkeley.nlp.math.DoubleArrays;
import edu.berkeley.nlp.math.SloppyMath;

/**
 * @author petrov
 *
 */
public class ScalingTools {
  // SCALING
	public static final int LOGSCALE = 100;
  public static final double SCALE = Math.exp(LOGSCALE);
  // Note: e^709 is the largest double java can handle.

  public static double calcScaleFactor(double logScale) {
  	return calcScaleFactor(logScale,SCALE);
  }
  
  public static double calcScaleFactor(double logScale, double scale) {
  	if (logScale==Integer.MIN_VALUE){
  		return 0.0;//System.out.println("give me a break!");
  	}
		if (logScale == 0.0)
			return 1.0;
		if (logScale == 1.0)
			return scale;
		if (logScale == 2.0)
			return scale * scale;
		if (logScale == 3.0)
			return scale * scale * scale;
		if (logScale == -1.0)
			return 1.0 / scale;
		if (logScale == -2.0)
			return 1.0 / scale / scale;
		if (logScale == -3.0)
			return 1.0 / scale / scale / scale;
		return Math.pow(scale, logScale);
	}
  
  public static int scaleArray(double[] scores, int previousScale){
  	if (previousScale==Integer.MIN_VALUE){
  		return previousScale;//System.out.println("give me a break!");
  	}
//  	if (true) return previousScale;
  	int logScale = 0;
	  double scale = 1.0;
	  double max = DoubleArrays.max(scores);
	  if (max==Double.POSITIVE_INFINITY) {
//	  	System.out.println("Infinity");
	  	return 0;
	  }
	  if (max==0) return previousScale;
	  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 < scores.length; i++) {
	      scores[i] /= scale;
	    }
	  }
//	  if (SloppyMath.isDangerous(ArrayMath.max(scores))){
//	  	System.out.println("Undeflow when scaling scores!");
//	  	}
	  return previousScale + logScale;
  }
  

  public static void scaleArrayToScale(double[] scores, int previousScale, int newScale){
	  int scaleDiff = previousScale-newScale;
	  if (scaleDiff == 0) return; // nothing to do
	  double max = DoubleArrays.max(scores);
	  if (SloppyMath.isDangerous(max)) return;

	  double scale = calcScaleFactor(scaleDiff);
	  
	  if (Math.abs(scaleDiff)>=800){
	  	// under-/overflow...
	  	Arrays.fill(scores,0.0);
	  	return;
	  }

	  for (int i = 0; i < scores.length; i++) {
      scores[i] *= scale;
    }
//	  if (SloppyMath.isDangerous(ArrayMath.max(scores))){
//	  	System.out.println("Undeflow when scaling scores!");
//	  	}
  }

  public static double scaleToScale(double score, int previousScale, int newScale){
	  int scaleDiff = previousScale-newScale;
	  if (scaleDiff == 0) return score; // nothing to do
	  double max = score;
	  
	  if (SloppyMath.isDangerous(max)) return 0;

	  double scale = calcScaleFactor(scaleDiff);
	  
	  if (Math.abs(scaleDiff)>=800){
	  	// under-/overflow...
	  	return 0;
	  }

    score *= scale;
    
    return score;
  }

  public static boolean isBadScale(int scale)
	{
		return scale == Integer.MIN_VALUE || scale == Integer.MAX_VALUE || scale == Integer.MAX_VALUE - 1 || scale == Integer.MIN_VALUE + 1 ||  scale == Integer.MAX_VALUE - 2 || scale == Integer.MIN_VALUE + 2;
	}


  

}