//public HyperGeometricProbability(int N=0, int n=0, int y=0, int r=0, NuGenProbability::RandomVariableType rvt=EQUAL);
/// <summary>
/// The HyperGeometric probability is defined by:
/// The equation: (rCy)*((N-r)C(n-y))/(NCn)
/// where (x C y ) represents a combination, "x choose y"
/// </summary>
/// <param name="N">the population size; N must be > 0</param>
/// <param name="n">the sample size; must be n is less than or equal to N</param>
/// <param name="y">the sample set of items we are interested in.</param>
/// <param name="r">the number of items from the sample set we are interested in. must be y is less than or equal to r</param>
/// <param name="rvt">type of the random variable</param>
public NuGenHyperGeometricProbability(int N, int n, int y, int r, RandomVariableType rvt)
: base(y, rvt)
{
m_population = N;
m_sample = n;
m_red = y;
m_black = n - y;
m_selectedset = r;
if (!(y <= r))
{
throw new NuGenProbabilityException("y <= r");
}
if (!(n - y <= N - r))
{
throw new NuGenProbabilityException("n-y <= N-r");
}
if (!(y >= 0))
{
throw new NuGenProbabilityException("y>=0");
}
if (!(N > 0))
{
throw new NuGenProbabilityException("N>0");
}
if (!(r >= 0))
{
throw new NuGenProbabilityException("r>=0");
}
if (!(n >= 0))
{
throw new NuGenProbabilityException("n>=0");
}
}
//public NuGenPoissonProbability(int Y=0,double Lambda=0,NuGenProbability::RandomVariableType rvt=EQUAL);
/// <summary>
/// The Poisson probability.
/// The equation for this probability is:
/// P(Y) = lambda^Y * e^lambda / Y!
/// </summary>
/// <param name="Y">The number of events we want to know the probability of happening given a known average in a given time period.</param>
/// <param name="Lambda">The average number of events in a given time period.</param>
/// <param name="rvt">The random variable type. Whether it is cumulative or not and which way.</param>
public NuGenPoissonProbability(int Y, double Lambda, RandomVariableType rvt): base(Y,rvt)
{
m_changes=Y;
m_poisson_average=Lambda;
if(!(Y >=0)) throw new NuGenProbabilityException("Y >=0");
if(!(Lambda >=0)) throw new NuGenProbabilityException("Lambda >=0");
}
//public GeometricProbability(int Y=0, double p=1.0, NuGenProbability::RandomVariableType rvt=EQUAL);
/* The discrete geometric probability
The equation for this probability is:
P(Y) = (1.0-p)^(y-1) * p
*/
/// <summary>
/// Constructs a geometric probability
/// </summary>
/// <param name="Y">The number of the trial that the success occurs on. Must be 0 is less than or equal to Y</param>
/// <param name="p">Chance of success for each trial. Must be 0.0 is less than or equal to p which is less than or equal to 1.0</param>
/// <param name="rvt">Random variable comparison. Whether this probability is cumulative and which way it is. </param>
public NuGenGeometricProbability(int Y, double p, RandomVariableType rvt) : base(Y,rvt)
{
m_trial_of_success=Y;
m_chance_of_success=p;
if(!(Y>=0)) throw new NuGenProbabilityException("Y>=0");
if(!(p >= 0.0 && p<=1.0)) throw new NuGenProbabilityException("p >= 0.0 && p<=1.0");
}
/* The discrete binomial probability.
The equation for this probability is:
P(Y) = N!/((N-Y)!Y!)*p^Y*(1-p)^(N-Y)
*/
#region Constructors
/// <summary>
/// Constructs a binomial probability
/// </summary>
/// <param name="N">number of trials of this experiment; must be 0 is less than or equal to N</param>
/// <param name="Y">number of successful trials; must be 0 is less than or equal to Y which is less than or equal to N</param>
/// <param name="p">chance of success for each trial; must be 0.0 is less than or equal to p which is less than or equal to 1.0</param>
/// <param name="rvt">Random variable comparison. Whether this probability is cumulative and which way it is.</param>
NuGenBinomialProbability(int N , int Y, double p, RandomVariableType rvt) : base(Y, rvt)
{
m_trials= N;
m_successes=Y;
m_chance_of_success=p;
if (!(Y<=N && Y >=0)) throw new NuGenProbabilityException("Y<=N && Y >=0");
if (!(p >=0.0 && p<=1.0)) throw new NuGenProbabilityException("p >=0.0 && p<=1.0");
}
public RandomVariableWindow(RandomVariable randomVariable)
{
this.Type = randomVariable.Type;
this.Title = randomVariable.Name;
RandomVariableList = randomVariable.Argument;
InitializeComponent();
UpdateContents();
this.CenterToParent();
}
//public NuGenNegativeBinomialProbability(int Y=1, int K=1, double p=0.0, NuGenProbability::RandomVariableType rvt=EQUAL);
/// <summary>
/// The Negative Binomial NuGenProbability
/// The equation for this probability is:
/// P(Y) = (Y-1)!/(((Y-1)-(K-1))!(K-1)!)*p^K*(1-p)^(Y-K)
/// </summary>
/// <param name="Y">number of the trial that the kth success happens; must be 0 less than or equal to Y</param>
/// <param name="K">number of successful trials; must be 0 is less than or equal to K which is less than or equal to Y</param>
/// <param name="p">chance of success for each trial; must be 0.0 is less than or equal to p which is less than or equal to 1.0</param>
/// <param name="rvt">Random variable comparison. Whether this probability is cumulative and which way it is.</param>
public NuGenNegativeBinomialProbability(int Y, int K, double p, RandomVariableType rvt) : base(Y,rvt)
{
m_trials=Y;
m_kth_success=K;
m_chance_of_success=p;
if(!(0<=Y && K>=0)) throw new NuGenProbabilityException("0<=Y && K>=0");
if(!(p >=0.0 && p<=1.0)) throw new NuGenProbabilityException("p >=0.0 && p<=1.0");
}
//public NuGenPoissonProbability(int Y=0,double Lambda=0,NuGenProbability::RandomVariableType rvt=EQUAL);
/// <summary>
/// The Poisson probability.
/// The equation for this probability is:
/// P(Y) = lambda^Y * e^lambda / Y!
/// </summary>
/// <param name="Y">The number of events we want to know the probability of happening given a known average in a given time period.</param>
/// <param name="Lambda">The average number of events in a given time period.</param>
/// <param name="rvt">The random variable type. Whether it is cumulative or not and which way.</param>
public NuGenPoissonProbability(int Y, double Lambda, RandomVariableType rvt) : base(Y, rvt)
{
m_changes = Y;
m_poisson_average = Lambda;
if (!(Y >= 0))
{
throw new NuGenProbabilityException("Y >=0");
}
if (!(Lambda >= 0))
{
throw new NuGenProbabilityException("Lambda >=0");
}
}
//public GeometricProbability(int Y=0, double p=1.0, NuGenProbability::RandomVariableType rvt=EQUAL);
/* The discrete geometric probability
* The equation for this probability is:
* P(Y) = (1.0-p)^(y-1) * p
*/
/// <summary>
/// Constructs a geometric probability
/// </summary>
/// <param name="Y">The number of the trial that the success occurs on. Must be 0 is less than or equal to Y</param>
/// <param name="p">Chance of success for each trial. Must be 0.0 is less than or equal to p which is less than or equal to 1.0</param>
/// <param name="rvt">Random variable comparison. Whether this probability is cumulative and which way it is. </param>
public NuGenGeometricProbability(int Y, double p, RandomVariableType rvt) : base(Y, rvt)
{
m_trial_of_success = Y;
m_chance_of_success = p;
if (!(Y >= 0))
{
throw new NuGenProbabilityException("Y>=0");
}
if (!(p >= 0.0 && p <= 1.0))
{
throw new NuGenProbabilityException("p >= 0.0 && p<=1.0");
}
}
//public NuGenNegativeBinomialProbability(int Y=1, int K=1, double p=0.0, NuGenProbability::RandomVariableType rvt=EQUAL);
/// <summary>
/// The Negative Binomial NuGenProbability
/// The equation for this probability is:
/// P(Y) = (Y-1)!/(((Y-1)-(K-1))!(K-1)!)*p^K*(1-p)^(Y-K)
/// </summary>
/// <param name="Y">number of the trial that the kth success happens; must be 0 less than or equal to Y</param>
/// <param name="K">number of successful trials; must be 0 is less than or equal to K which is less than or equal to Y</param>
/// <param name="p">chance of success for each trial; must be 0.0 is less than or equal to p which is less than or equal to 1.0</param>
/// <param name="rvt">Random variable comparison. Whether this probability is cumulative and which way it is.</param>
public NuGenNegativeBinomialProbability(int Y, int K, double p, RandomVariableType rvt) : base(Y, rvt)
{
m_trials = Y;
m_kth_success = K;
m_chance_of_success = p;
if (!(0 <= Y && K >= 0))
{
throw new NuGenProbabilityException("0<=Y && K>=0");
}
if (!(p >= 0.0 && p <= 1.0))
{
throw new NuGenProbabilityException("p >=0.0 && p<=1.0");
}
}
/* The discrete binomial probability.
* The equation for this probability is:
* P(Y) = N!/((N-Y)!Y!)*p^Y*(1-p)^(N-Y)
*/
#region Constructors
/// <summary>
/// Constructs a binomial probability
/// </summary>
/// <param name="N">number of trials of this experiment; must be 0 is less than or equal to N</param>
/// <param name="Y">number of successful trials; must be 0 is less than or equal to Y which is less than or equal to N</param>
/// <param name="p">chance of success for each trial; must be 0.0 is less than or equal to p which is less than or equal to 1.0</param>
/// <param name="rvt">Random variable comparison. Whether this probability is cumulative and which way it is.</param>
NuGenBinomialProbability(int N, int Y, double p, RandomVariableType rvt) : base(Y, rvt)
{
m_trials = N;
m_successes = Y;
m_chance_of_success = p;
if (!(Y <= N && Y >= 0))
{
throw new NuGenProbabilityException("Y<=N && Y >=0");
}
if (!(p >= 0.0 && p <= 1.0))
{
throw new NuGenProbabilityException("p >=0.0 && p<=1.0");
}
}
//public HyperGeometricProbability(int N=0, int n=0, int y=0, int r=0, NuGenProbability::RandomVariableType rvt=EQUAL);
/// <summary>
/// The HyperGeometric probability is defined by:
/// The equation: (rCy)*((N-r)C(n-y))/(NCn)
/// where (x C y ) represents a combination, "x choose y"
/// </summary>
/// <param name="N">the population size; N must be > 0</param>
/// <param name="n">the sample size; must be n is less than or equal to N</param>
/// <param name="y">the sample set of items we are interested in.</param>
/// <param name="r">the number of items from the sample set we are interested in. must be y is less than or equal to r</param>
/// <param name="rvt">type of the random variable</param>
public NuGenHyperGeometricProbability(int N, int n, int y, int r, RandomVariableType rvt) : base(y,rvt)
{
m_population=N;
m_sample=n;
m_red=y;
m_black=n-y;
m_selectedset=r;
if (!(y <= r)) throw new NuGenProbabilityException("y <= r");
if (!(n-y <= N-r)) throw new NuGenProbabilityException("n-y <= N-r");
if (!(y>=0)) throw new NuGenProbabilityException("y>=0");
if (!(N>0)) throw new NuGenProbabilityException("N>0");
if (!(r>=0)) throw new NuGenProbabilityException("r>=0");
if (!(n>=0)) throw new NuGenProbabilityException("n>=0");
}
public RandomVariable(RandomVariableType rvType)
{
switch (rvType)
{
case RandomVariableType.Uniform:
this.Name = "Unifrom Random Variable";
this.Argument.Add(new Variable(name: "X", dataType: DataType.Integer, isList: true));
break;
case RandomVariableType.Binomial:
this.Name = "Binomial Random Variable";
this.Argument.Add(new Variable(name: "r", dataType: DataType.Integer, isList: true));
this.Argument.Add(new Variable(name: "n", dataType: DataType.Integer));
this.Argument.Add(new Variable(name: "p", dataType: DataType.Float));
break;
case RandomVariableType.Poisson:
this.Name = "Poisson Random Variable";
this.Argument.Add(new Variable(name: "k", dataType: DataType.Integer, isList: true));
this.Argument.Add(new Variable(name: MathSymbol.Lambda, dataType: DataType.Float));
this.Argument.Add(new Variable(name: "w", dataType: DataType.Float, presetValue: "1"));
break;
case RandomVariableType.Geometric:
this.Name = "Geometric Random Variable";
this.Argument.Add(new Variable(name: "n", dataType: DataType.Integer));
this.Argument.Add(new Variable(name: "p", dataType: DataType.Float));
break;
case RandomVariableType.NegativeBinomial:
this.Name = "Negative Binomial Random Variable";
this.Argument.Add(new Variable(name: "n", dataType: DataType.Integer));
this.Argument.Add(new Variable(name: "p", dataType: DataType.Float));
this.Argument.Add(new Variable(name: "r", dataType: DataType.Integer));
break;
case RandomVariableType.HyperGeometric:
this.Name = "Hyper-Geometric Random Variable";
this.Argument.Add(new Variable(name: "N", dataType: DataType.Integer));
this.Argument.Add(new Variable(name: "n", dataType: DataType.Integer));
this.Argument.Add(new Variable(name: "r", dataType: DataType.Integer));
this.Argument.Add(new Variable(name: "k", dataType: DataType.Integer));
break;
}
}
private static Label GetDescriptionLabel(RandomVariableType type)
{
Label descriptionLabel = new Label();
Image labelImage = null;
switch (type)
{
case RandomVariableType.Uniform:
labelImage = Resources.uniformRVTex;
break;
case RandomVariableType.Binomial:
labelImage = Resources.binomialRVTex;
break;
case RandomVariableType.Poisson:
labelImage = Resources.poissonRVTex;
break;
case RandomVariableType.Geometric:
labelImage = Resources.geometricRVTex;
break;
case RandomVariableType.NegativeBinomial:
labelImage = Resources.negBinomialRVTex;
break;
case RandomVariableType.HyperGeometric:
labelImage = Resources.hyperGeoRVTex;
break;
}
double scale = 0.8;
Size scaledSize = new Size((int)(labelImage.Width * scale), (int)(labelImage.Height * scale));
descriptionLabel.Image = (Image)(new Bitmap(labelImage, scaledSize));
return(descriptionLabel);
}
/// <summary>
///
/// </summary>
/// <param name="rv">The Random Variable value.</param>
/// <param name="rvt">Random Variable type, whether it is cumulative and which way it is cumulative.</param>
/// <param name="prob">The probability of the event. This can be set before hand if it is known and the GetResult function will return it.</param>
public NuGenProbability( int rv, RandomVariableType rvt, double prob)
{
m_RV=rv; m_RVT=rvt; m_probability=prob;
}
/// <summary>
///
/// </summary>
/// <param name="rv">The Random Variable value.</param>
/// <param name="rvt">Random Variable type, whether it is cumulative and which way it is cumulative.</param>
/// <param name="prob">The probability of the event. This can be set before hand if it is known and the GetResult function will return it.</param>
public NuGenProbability(int rv, RandomVariableType rvt, double prob)
{
m_RV = rv; m_RVT = rvt; m_probability = prob;
}
public NuGenProbability(int rv, RandomVariableType rvt) : this(rv, rvt, UNDEFINED)
{
}
public NuGenProbability(int rv, RandomVariableType rvt) : this(rv, rvt, UNDEFINED)
{
}
