How to use org.ddogleg.stats

/**
 * compute the weights by convolving 1D gaussian kernel
 */
protected void computeWeights(int numSamples, double numSigmas) {
  weights = new float[ numSamples*numSamples ];
  float w[] = new float[ numSamples ];
  for( int i = 0; i < numSamples; i++ ) {
    float x = i/(float)(numSamples-1);
    w[i] = (float) UtilGaussian.computePDF(0, 1, 2f*numSigmas * (x - 0.5f));
  }
  for( int y = 0; y < numSamples; y++ ) {
    for( int x = 0; x < numSamples; x++ ) {
      weights[y*numSamples + x] = w[y]*w[x];
    }
  }
}

public static double stdev( GrowQueue_F64 list , double mean ) {
  return Math.sqrt(variance(list,mean));
}

public static double deriv3( double mu , double sigma ,double x) {
  double d = 1e-1;
  return (deriv2(mu,sigma,x+d) - deriv2(mu,sigma,x-d))/(2*d);
}
public static double deriv4( double mu , double sigma ,double x) {

case 1:
  for (int i = radius; i >= -radius; i--) {
    gaussian[index++] = (float) UtilGaussian.derivative1(0, sigma, i);
    gaussian[index++] = (float) UtilGaussian.derivative2(0, sigma, i);
    gaussian[index++] = (float) UtilGaussian.derivative3(0, sigma, i);
    gaussian[index++] = (float) UtilGaussian.derivative4(0, sigma, i);
double sum = 0;
for (int i = radius; i >= -radius; i--) {
  sum += UtilGaussian.computePDF(0, sigma, i);

@Test
public void derivative3() {
  // numerical derivative.. test is very crude
  double expected = deriv3(1.5, 2, 1.8);
  assertEquals(expected, UtilGaussian.derivative3(1.5, 2, 1.8), 1e-3);
}

@Test
public void derivative2() {
  // numerical derivative.. test is very crude
  double expected = deriv2(1.5, 2, 1.8);
  assertEquals(expected, UtilGaussian.derivative2(1.5, 2, 1.8), 1e-3);
}

@Test
public void derivative1() {
  // numerical derivative
  double expected = deriv1(1.5, 2, 1.8);
  assertEquals(expected,UtilGaussian.derivative1(1.5, 2, 1.8),1e-4);
}

@Test
public void derivative4() {
  // numerical derivative.. test is very crude
  double expected = deriv4(1.5, 2, 1.8);
  assertEquals(expected, UtilGaussian.derivative4(1.5, 2, 1.8), 0.1);
}

  public static double deriv4( double mu , double sigma ,double x) {
    double d = 0.1;
    return (deriv3(mu, sigma, x + d) - deriv3(mu, sigma, x - d))/(2*d);
  }
}

public static double deriv1( double mu , double sigma ,double x) {
  return (normal(mu,sigma,x+1e-10) - normal(mu,sigma,x))/1e-10;
}
public static double deriv2( double mu , double sigma ,double x) {

public static double deriv2( double mu , double sigma ,double x) {
  return (deriv1(mu,sigma,x+1e-3) - deriv1(mu,sigma,x-1e-3))/2e-3;
}
public static double deriv3( double mu , double sigma ,double x) {

  @Test
  public void fraction_F64() {

    GrowQueue_F64 l = new GrowQueue_F64();
    for (int i = 0; i < 100; i++) {
      l.add(i);
    }

    assertEquals(50,UtilStatisticsQueue.fraction(l,0.5),1e-8);
    assertEquals(0,UtilStatisticsQueue.fraction(l,0),1e-8);
    assertEquals(99,UtilStatisticsQueue.fraction(l,1.0),1e-8);
  }
}

@Test
public void mean_F64() {
  GrowQueue_F64 l = new GrowQueue_F64();
  l.add(0);
  l.add(1);
  l.add(2);
  l.add(3);
  l.add(4);
  double found = UtilStatisticsQueue.mean(l);
  assertEquals(2,found,1e-8);
}

for (int row = 0; row < rows; row++) {
  double drow = row-radiusRow+offsetRow;
  double pdfRow = UtilGaussian.computePDF(0, radiusRow, drow);
    double pdfCol = UtilGaussian.computePDF(0, radiusCol, dcol);

public static double stdev( GrowQueue_F64 list , double mean ) {
  return Math.sqrt(variance(list,mean));
}

protected static Kernel1D_F64 gaussian1D_F64(double sigma, int radius, boolean odd, boolean normalize) {
  Kernel1D_F64 ret;
  if( odd ) {
    ret = new Kernel1D_F64(radius * 2 + 1);
    int index = 0;
    for (int i = radius; i >= -radius; i--) {
      ret.data[index++] = UtilGaussian.computePDF(0, sigma, i);
    }
  } else {
    ret = new Kernel1D_F64(radius * 2);
    int index = 0;
    for (int i = radius; i > -radius; i--) {
      ret.data[index++] = UtilGaussian.computePDF(0, sigma, i-0.5);
    }
  }
  if (normalize) {
    KernelMath.normalizeSumToOne(ret);
  }
  return ret;
}

@Test
public void variance_F64() {
  GrowQueue_F64 l = new GrowQueue_F64();
  l.add(0);
  l.add(1);
  l.add(2);
  l.add(3);
  l.add(4);
  double found = UtilStatisticsQueue.variance(l,2);
  assertEquals(2.5,found,1e-8);
}

/**
 * Test the PDF based on some of its properties
 */
@Test
public void computePDF() {
  double max = UtilGaussian.computePDF(2,1.5,2);
  assertTrue( UtilGaussian.computePDF(2,1.5,1) < max );
  assertTrue( UtilGaussian.computePDF(2,1.5,3) < max );
  assertEquals(UtilGaussian.computePDF(2, 1.5, 1),UtilGaussian.computePDF(2, 1.5, 3),1e-8 );
  assertTrue( UtilGaussian.computePDF(2,2,2) < max );
  assertTrue( UtilGaussian.computePDF(2,1,2) > max );
}

/**
 * <p>
 * Creates a floating point Gaussian kernel with the sigma and radius.
 * If normalized is set to true then the elements in the kernel will sum up to one.
 * </p>
 * @param sigma     Distributions standard deviation.
 * @param radius    Kernel's radius.
 * @param odd Does the kernel have an even or add width
 * @param normalize If the kernel should be normalized to one or not.
 */
protected static Kernel1D_F32 gaussian1D_F32(double sigma, int radius, boolean odd, boolean normalize) {
  Kernel1D_F32 ret;
  if( odd ) {
    ret = new Kernel1D_F32(radius * 2 + 1);
    int index = 0;
    for (int i = radius; i >= -radius; i--) {
      ret.data[index++] = (float) UtilGaussian.computePDF(0, sigma, i);
    }
  } else {
    ret = new Kernel1D_F32(radius * 2);
    int index = 0;
    for (int i = radius; i > -radius; i--) {
      ret.data[index++] = (float) UtilGaussian.computePDF(0, sigma, i-0.5);
    }
  }
  if (normalize) {
    KernelMath.normalizeSumToOne(ret);
  }
  return ret;
}

double dx = x <= r ? Math.abs(x-r)+0.5 : Math.abs(x-r-1)+0.5;
double d = Math.sqrt(dx*dx + dy*dy);
double val = UtilGaussian.computePDF(0,sigma,d);
ret.set(x,y,val);
sum += val;