/* *
 * Title:        

 * Description:  

 * Copyright:    Copyright (c) 

 * Company:      

 * @author
 * @version 1.0
 */


package umontreal.iro.lecuyer.stochprocess;
import umontreal.iro.lecuyer.rng.*;
import umontreal.iro.lecuyer.probdist.*;
import umontreal.iro.lecuyer.randvar.*;



/**
 * .
 * 
 * The geometric normal inverse gaussian (GNIG) process
 * is the exponentiation of a {@link NormalInverseGaussianProcess}:
 * 

 * 
 * 

 * S(t) = S0exp[(r - ωRN)t + NIG(t;α, β, μ, δ)],
 * 

 * where  r is the interest rate.
 * It is a strictly positive process, which is useful in finance.
 * There is also a neutral
 * correction in the exponential, 
 * ωRN = μ + δγ - δ(α^2-(1+β)^2)1/2,
 * which takes into account the market price of risk.
 * The underlying NIG process must start at zero, NIG(t0) = 0
 * and the initial time should also be set to zero, t0 = 0,
 * both for the NIG and GNIG.
 * 
 */
public class GeometricNormalInverseGaussianProcess extends
                                                   GeometricLevyProcess  {



   /**
    * Constructs a new GeometricNormalInverseGaussianProcess.
    * The parameters of the NIG process will be overwritten by the parameters
    * given to the GNIG, with the initial value of the NIG set to 0.
    * The observation times of the NIG will also be changed to
    * those of the GNIG.
    * 
    */
   public GeometricNormalInverseGaussianProcess (
                                        double s0, double muGeom,
                                        double alpha, double beta,
                                        double mu, double delta,
                                        RandomStream streamBrownian,
                                        NormalInverseGaussianProcess nigP) {
        levyProcess = nigP;
        ((NormalInverseGaussianProcess)levyProcess).setParams(0.0, alpha, beta, mu, delta);
        this.x0 = s0;
        this.muGeom = muGeom;
        omegaRiskNeutralCorrection =
            mu + delta*((NormalInverseGaussianProcess)levyProcess).getGamma() -
            delta*Math.sqrt(alpha*alpha - (1.+beta)*(1.+beta));
    }


   /**
    * Constructs a new GeometricNormalInverseGaussianProcess.
    * The process igP
    * will be used internally by the underlying {@link NormalInverseGaussianProcess}.
    * 
    */
   public GeometricNormalInverseGaussianProcess (
                                        double s0, double muGeom,
                                        double alpha, double beta,
                                        double mu, double delta,
                                        RandomStream streamBrownian,
                                        InverseGaussianProcess igP)  {

        levyProcess = new NormalInverseGaussianProcess (0.0, alpha, beta, mu,
                                                        delta, streamBrownian, igP);
        this.x0 = s0;
        this.muGeom = muGeom;
        omegaRiskNeutralCorrection =
            mu + delta*((NormalInverseGaussianProcess)levyProcess).getGamma() -
            delta*Math.sqrt(alpha*alpha - (1.+beta)*(1.+beta));
    }


   /**
    * Constructs a new GeometricNormalInverseGaussianProcess.
    * The drift of the geometric term, muGeom, is usually the interest rate r.
    * s0 is the initial value of the process and the other four parameters
    * are the parameters of the underlying {@link NormalInverseGaussianProcess} process.
    * 
    */
   public GeometricNormalInverseGaussianProcess (
                                        double s0, double muGeom,
                                        double alpha, double beta,
                                        double mu, double delta,
                                        RandomStream streamBrownian,
                                        RandomStream streamNIG1,
                                        RandomStream streamNIG2,
                                        String igType)  {
        levyProcess = new NormalInverseGaussianProcess (0.0, alpha, beta, mu, delta,
                                                        streamBrownian, streamNIG1,
                                                        streamNIG2, igType);
        this.x0 = s0;
        this.muGeom = muGeom;
        omegaRiskNeutralCorrection =
            mu + delta*((NormalInverseGaussianProcess)levyProcess).getGamma() -
            delta*Math.sqrt(alpha*alpha - (1.+beta)*(1.+beta));
    }


   /**
    * Constructs a new GeometricNormalInverseGaussianProcess.
    * The String igType corresponds to the type of {@link InverseGaussianProcess}
    * that will be used by the underlying {@link NormalInverseGaussianProcess}.
    * All {@link umontreal.iro.lecuyer.rng.RandomStream RandomStream}'s used to generate the underlying
    * {@link NormalInverseGaussianProcess} and its underlying {@link InverseGaussianProcess}
    * are set to the same given streamAll.
    * 
    */
   public GeometricNormalInverseGaussianProcess (
                                        double s0, double muGeom,
                                        double alpha, double beta,
                                        double mu, double delta,
                                        RandomStream streamAll,
                                        String igType)  {
        this(s0,muGeom,alpha,beta,mu,delta,streamAll,streamAll,streamAll,igType);
    }


}