FisherFDist.java

/*
 * Class:        FisherFDist
 * Description:  Fisher F-distribution
 * Environment:  Java
 * Software:     SSJ 
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       
 * @since
 *
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package umontreal.ssj.probdist;
 
import umontreal.ssj.probdist.BetaDist;
import umontreal.ssj.util.*;

public class FisherFDist extends ContinuousDistribution {
   protected int n1;
   protected int n2;
   protected double C1;
   private static final int DECPREC = 15; // decimal precision

   public FisherFDist(int n1, int n2) {
      setParams(n1, n2);
   }
 
   public double density(double x) {
      if (x <= 0.0)
         return 0.0;
      return Math.exp(C1 + 0.5 * (n1 - 2) * Math.log(x) - (0.5 * (n1 + n2) * Math.log(n2 + n1 * x)));
   }
 
   public double cdf(double x) {
      return FisherFDist.cdf(n1, n2, x);
   }
 
   public double barF(double x) {
      return FisherFDist.barF(n1, n2, x);
   }
 
   public double inverseF(double u) {
      return FisherFDist.inverseF(n1, n2, u);
   }
 
   public double getMean() {
      return FisherFDist.getMean(n1, n2);
   }
 
   public double getVariance() {
      return FisherFDist.getVariance(n1, n2);
   }
 
   public double getStandardDeviation() {
      return FisherFDist.getStandardDeviation(n1, n2);
   }

   public static double density(int n1, int n2, double x) {
      if (n1 <= 0)
         throw new IllegalArgumentException("n1 <= 0");
      if (n2 <= 0)
         throw new IllegalArgumentException("n2 <= 0");
      if (x <= 0.0)
         return 0.0;
 
      return Math.exp(((n1 / 2.0) * Math.log(n1) + (n2 / 2.0) * Math.log(n2) + ((n1 - 2) / 2.0) * Math.log(x))
            - (Num.lnBeta(n1 / 2.0, n2 / 2.0) + ((n1 + n2) / 2.0) * Math.log(n2 + n1 * x)));
   }

   @Deprecated
   public static double cdf(int n1, int n2, int d, double x) {
      if (n1 <= 0)
         throw new IllegalArgumentException("n1 <= 0");
      if (n2 <= 0)
         throw new IllegalArgumentException("n2 <= 0");
      if (x <= 0.0)
         return 0.0;
      return BetaDist.cdf(n1 / 2.0, n2 / 2.0, (n1 * x) / (n1 * x + n2));
   }

   public static double cdf(int n1, int n2, double x) {
      return cdf(n1, n2, DECPREC, x);
   }

   @Deprecated
   public static double barF(int n1, int n2, int d, double x) {
      if (n1 <= 0)
         throw new IllegalArgumentException("n1 <= 0");
      if (n2 <= 0)
         throw new IllegalArgumentException("n2 <= 0");
      if (x <= 0.0)
         return 1.0;
      return BetaDist.barF(n1 / 2.0, n2 / 2.0, (n1 * x) / (n1 * x + n2));
   }

   public static double barF(int n1, int n2, double x) {
      return barF(n1, n2, DECPREC, x);
   }

   @Deprecated
   public static double inverseF(int n1, int n2, int d, double u) {
      if (n1 <= 0)
         throw new IllegalArgumentException("n1 <= 0");
      if (n2 <= 0)
         throw new IllegalArgumentException("n2 <= 0");
      if (u > 1.0 || u < 0.0)
         throw new IllegalArgumentException("u < 0 or u > 1");
      if (u <= 0.0)
         return 0.0;
      if (u >= 1.0)
         return Double.POSITIVE_INFINITY;
 
      double z = BetaDist.inverseF(n1 / 2.0, n2 / 2.0, d, u);
      return ((n2 * z) / (n1 * (1 - z)));
   }

   public static double inverseF(int n1, int n2, double u) {
      return inverseF(n1, n2, DECPREC, u);
   }

   public static double getMean(int n1, int n2) {
      if (n1 <= 0)
         throw new IllegalArgumentException("n1 <= 0");
      if (n2 <= 2)
         throw new IllegalArgumentException("n2 <= 2");
 
      return (n2 / (n2 - 2.0));
   }

   public static double getVariance(int n1, int n2) {
      if (n1 <= 0)
         throw new IllegalArgumentException("n1 <= 0");
      if (n2 <= 4)
         throw new IllegalArgumentException("n2 <= 4");
 
      return ((2.0 * n2 * n2 * (n2 + n1 - 2)) / (n1 * (n2 - 2.0) * (n2 - 2.0) * (n2 - 4.0)));
   }

   public static double getStandardDeviation(int n1, int n2) {
      return Math.sqrt(FisherFDist.getVariance(n1, n2));
   }

   public int getN1() {
      return n1;
   }

   public int getN2() {
      return n2;
   }

   public void setParams(int n1, int n2) {
      if (n1 <= 0)
         throw new IllegalArgumentException("n1 <= 0");
      if (n2 <= 0)
         throw new IllegalArgumentException("n2 <= 0");
 
      this.n1 = n1;
      this.n2 = n2;
      supportA = 0;
      C1 = (n1 / 2.0) * Math.log(n1) + (n2 / 2.0) * Math.log(n2) - Num.lnBeta(n1 / 2.0, n2 / 2.0);
   }

   public double[] getParams() {
      double[] retour = { n1, n2 };
      return retour;
   }

   public String toString() {
      return getClass().getSimpleName() + " : n1 = " + n1 + ", n2 = " + n2;
   }
 
}