Esempio n. 1
0
  /**
   * As described by Bernt Arne Ødegaard in Financial Numerical Recipes in C++.
   *
   * <p>Returns P(X < a, Y < b) where X, Y are gaussian random variables N(0, 1) of the bivariate
   * normal distribution with correlation c in [-1, 1] between X and Y.
   */
  public static double cdf(double a, double b, double c) {
    if (a == Double.NaN || b == Double.NaN || c == Double.NaN) {
      throw new IllegalArgumentException("Arguments must be a number.");
    }

    if (a == Double.NaN) {
      System.out.println("");
    }

    a = handleInfinity(a);
    b = handleInfinity(b);
    c = handleInfinity(c);

    if (a == Double.NaN) {
      System.out.println("");
    }

    if (a <= 0 && b <= 0 && c <= 0) {
      final double aprime = a / FastMath.sqrt(2d * (1d - c * c));
      final double bprime = b / FastMath.sqrt(2d * (1d - c * c));
      double sum = 0;
      for (int i = 0; i < A.length; i++) {
        for (int j = 0; j < A.length; j++) {
          sum += A[i] * A[j] * f(B[i], B[j], aprime, bprime, c);
        }
      }

      sum *= FastMath.sqrt(1d - c * c) / FastMath.PI;

      return sum;
    }

    // a or b may be too big and their multiplication may result in NaN.
    if (c * a * b
        <= 0) { // c is smaller (between [-1, 1]) and will help to avoid NaNs. So we multiply c
      // first.
      if ((a <= 0) && (b >= 0) && (c >= 0)) {
        return normal.cumulativeProbability(a) - cdf(a, -b, -c);
      } else if ((a >= 0) && (b <= 0) && (c >= 0)) {
        return normal.cumulativeProbability(b) - cdf(-a, b, -c);
      } else if ((a >= 0) && (b >= 0) && (c <= 0)) {
        return normal.cumulativeProbability(a)
            + normal.cumulativeProbability(b)
            - 1
            + cdf(-a, -b, c);
      }
    } else if (c * a * b >= 0) {
      final double denum = FastMath.sqrt(a * a - 2d * c * a * b + b * b);
      final double rho1 = ((c * a - b) * FastMath.signum(a)) / denum;
      final double rho2 = ((c * b - a) * FastMath.signum(b)) / denum;
      final double delta = (1d - FastMath.signum(a) * FastMath.signum(b)) / 4d;
      return cdf(a, 0, rho1) + cdf(b, 0, rho2) - delta;
    }

    throw new RuntimeException(
        "Should never get here. Values of [a; b ; c] = [" + a + "; " + b + "; " + c + "].");
  }
  @Override
  protected OperationData process(IDataset input, IMonitor monitor) {

    double theta = 0;
    try {
      theta = ScanMetadata.getTheta(input);
    } catch (Exception e) {
    }

    NormalDistribution beamfootprint =
        new NormalDistribution(
            0, (1e-3 * model.getBeamHeight() / 2 * Math.sqrt(2 * Math.log(2) - 0.5)));
    double areaCorrection =
        2
            * (beamfootprint.cumulativeProbability(
                (model.getFootprint()
                    * Math.sin((theta + model.getAngularFudgeFactor()) * Math.PI / 180))));

    Dataset output = DatasetUtils.cast(input, Dataset.FLOAT64);

    output = Maths.multiply(input, areaCorrection);

    Dataset outputSum =
        DatasetFactory.createFromObject((DatasetUtils.cast(output, Dataset.FLOAT64)).sum());

    return new OperationData(output, outputSum);
  }
Esempio n. 3
0
  @Test
  /** Test of integrator for the sine function. */
  public void testSinFunction() {

    UnivariateFunction f = new Gaussian(10, 2);
    UnivariateIntegrator integrator = new SimpsonIntegrator();
    double a, b, expected, tolerance, result;

    a = 8;
    b = 12;
    expected = 0.68269;
    tolerance = 0.00001;

    tolerance = Math.abs(expected * integrator.getRelativeAccuracy());
    result = integrator.integrate(MAX_EVAL, f, a, b);
    assertEquals(expected, result, tolerance);

    log.info(
        "Result: "
            + result
            + ", tolerance: "
            + tolerance
            + " - Relative accuracy: "
            + integrator.getRelativeAccuracy()
            + " - Absolute accuracy: "
            + integrator.getAbsoluteAccuracy()
            + " - Iterations: "
            + integrator.getIterations());

    NormalDistribution distribution = new NormalDistribution(10, 2);
    result = distribution.cumulativeProbability(a, b);
    log.info("Distribution result: " + result);
  }
Esempio n. 4
0
  // Model "a" with a normal distribution, and test whether cdf(mean(b)) > pvalue
  public boolean significantIncrease(List<Double> a, List<Double> b, double pvalue) {
    double meanA = mean(a);
    double sd = 0;
    for (Double val : a) {
      sd += (val - meanA) * (val - meanA);
    }
    sd = Math.sqrt(sd / (a.size() - 1));

    if (sd <= 0) {
      return true;
    }

    double meanB = mean(b);
    NormalDistribution dist = new NormalDistribution(meanA, sd);
    double p = dist.cumulativeProbability(meanB);

    boolean significant = (p > pvalue);
    System.out.println("p-value=" + p + ", " + (significant ? "increase" : "no increase"));
    return significant;
  }
Esempio n. 5
0
 public static double normalCDF(double x, double mean, double sigma) {
   NormalDistribution normDist = new NormalDistribution(mean, sigma);
   double ret = normDist.cumulativeProbability(x);
   return ret;
 }