code: /**
   * 
   */
  package edu.berkeley.nlp.PCFGLA.smoothing;
  
  import edu.berkeley.nlp.PCFGLA.BinaryCounterTable;
  import edu.berkeley.nlp.PCFGLA.BinaryRule;
  import edu.berkeley.nlp.PCFGLA.UnaryCounterTable;
  import edu.berkeley.nlp.PCFGLA.UnaryRule;
  
  /**
   * @author leon
   * 
   */
  public class SmoothAcrossParentSubstateTest {
  
  	public SmoothAcrossParentSubstateTest() {
  		// CLASS IS BROKEN
  	}
  
  	/*
  	 * Test method for
  	 * 'edu.berkeley.nlp.PCFGLA.smoothing.SmoothAcrossParentSubstate.smooth(UnaryCounterTable,
  	 * BinaryCounterTable)'
  	 */
  	public void testSmooth() {
  		short pState = 1, lState = 2, rState = 3;
  		short[] numSubStates = { 3, 3, 3, 3 };
  		double[][] uScores = { { 1, 0, 0 }, { 1, 1, 1 }, { 0, 0, 1 } };
  		double[][] targetUScores = { { 0.75, 0.25, 0.5 }, { 0.75, 0.5, 0.75 },
  				{ 0.5, 0.25, 0.75 } };
  		double[][][] bScores = { { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } },
  				{ { 0, 1, 0 }, { 0, 0, 0 }, { 0, 0, 0 } },
  				{ { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } } };
  		double[][][] targetBScores = {
  				{ { 0.5, 0.25, 0 }, { 0, 0.5, 0 }, { 0, 0, 0.5 } },
  				{ { 0.25, 0.5, 0 }, { 0, 0.25, 0 }, { 0, 0, 0.25 } },
  				{ { 0.25, 0.25, 0 }, { 0, 0.25, 0 }, { 0, 0, 0.25 } } };
  
  		UnaryRule ur = new UnaryRule(pState, lState, uScores);
  		BinaryRule br = new BinaryRule(pState, lState, rState, bScores);
  		Smoother sm = new SmoothAcrossParentSubstate(0.5);
  		UnaryCounterTable unaryCounter = new UnaryCounterTable(numSubStates);
  		unaryCounter.setCount(ur, uScores);
  		BinaryCounterTable binaryCounter = new BinaryCounterTable(numSubStates);
  		binaryCounter.setCount(br, bScores);
  		sm.smooth(unaryCounter, binaryCounter);
  
  		double[][] newUScores = unaryCounter.getCount(ur);
  		for (int i = 0; i < newUScores.length; i++) {
  			for (int j = 0; j < newUScores[i].length; j++) {
  				// assertEquals(newUScores[i][j],targetUScores[i][j],0.0001);
  			}
  		}
  		double[][][] newBScores = binaryCounter.getCount(br);
  		for (int i = 0; i < newBScores.length; i++) {
  			for (int j = 0; j < newBScores[i].length; j++) {
  				for (int k = 0; k < newBScores[i][j].length; k++) {
  					// assertEquals(newBScores[i][j][k],targetBScores[i][j][k],0.0001);
  				}
  			}
  		}
  	}
  
  }
  