package umontreal.iro.lecuyer.randvar;

import umontreal.iro.lecuyer.rng.*;
import umontreal.iro.lecuyer.probdist.*;


/**
 * This class implements random variate generators for
 * the inverse gamma distribution with shape parameter
 * 
 * α > 0 and scale parameter β > 0.
 * The density function of this distribution is
 * 

 * 
 * 

 * f (x) = (βαexp-β/x)/(Γ(α)xα+1)        for x > 0,
 * 

 * and f (x) = 0 otherwise,
 * where Γ is the gamma function.
 * 
 */
public class InverseGammaGen extends RandomVariateGen  {
   protected double alpha;
   protected double beta;




   /**
    * Creates an inverse gamma random variate generator with parameters
    *   α = alpha and β = beta, using stream s.
    * 
    */
   public InverseGammaGen (RandomStream s, double alpha, double beta)  {
      super (s, new InverseGammaDist(alpha, beta));
      setParams(alpha, beta);
   }


   /**
    * Creates an inverse gamma random variate generator with parameters
    *  α = alpha and β = 1, using stream s.
    * 
    */
   public InverseGammaGen (RandomStream s, double alpha)  {
      this (s, alpha, 1.0);
   }


   /**
    * Creates a new generator for the distribution dist,
    *    using stream s.
    * 
    */
   public InverseGammaGen (RandomStream s, InverseGammaDist dist)  {
      super (s, dist);
      if (dist != null)
         setParams(dist.getAlpha(), dist.getBeta());
   }


   /**
    * Generates a variate from the inverse gamma distribution
    *    with shape parameter 
    * α > 0 and scale parameter β > 0.
    * 
    */
   public static double nextDouble (RandomStream s,
                                    double alpha, double beta) {
      return InverseGammaDist.inverseF (alpha, beta, s.nextDouble());
   }


   /**
    * Returns the parameter α of this object.
    * 
    */
   public double getAlpha() {
      return alpha;
   }


   /**
    * Returns the parameter β of this object.
    * 
    */
   public double getBeta() {
      return beta;
   }


   protected void setParams (double alpha, double beta) {
      if (alpha <= 0.0)
         throw new IllegalArgumentException ("alpha <= 0");
      if (beta <= 0.0)
         throw new IllegalArgumentException ("beta <= 0");
      this.alpha = alpha;
      this.beta = beta;
   }
}