public void Conversion()
{
UcumTestSet reader = new UcumTestSet();
foreach (UcumTestSet.Conversion conversion in reader.Conversions())
{
string expression = conversion.Value + conversion.SourceUnit;
Quantity quantity = system.Canonical(expression);
Exponential value = new Exponential(conversion.Outcome);
Metric metric = system.Metric(conversion.DestUnit);
try
{
Assert.AreEqual(metric, quantity.Metric);
Assert.IsTrue(Exponential.Similar(value, quantity.Value));
}
catch (Exception e)
{
throw new AssertFailedException(string.Format("Test {0} failed", conversion.Id), e);
}
}
}
public decimal Calculate(string calculate, decimal num1, decimal num2)
{
//int first = Convert.ToInt32(num1);
//int second = Convert.ToInt32(num2);
switch (calculate)
{
case "1":
Addition addition = new Addition();
answer = addition.AddThese(num1, num2);
Console.WriteLine("Your answer is: " + answer);
break;
case "2":
Subtraction subtraction = new Subtraction();
answer = subtraction.SubtractThese(num1, num2);
Console.WriteLine("Your answer is: " + answer);
break;
case "3":
Multiply multiply = new Multiply();
answer = multiply.MultiplyThese(num1, num2);
Console.WriteLine("Your answer is: " + answer);
break;
case "4":
Divide divide = new Divide();
answer = divide.DivideThese(num1, num2);
Console.WriteLine("Your answer is: " + answer);
break;
case "5":
Exponential exponential = new Exponential();
exponential.ExponentThese(num1, num2);
break;
default:
Console.WriteLine("Not a valid choice!");
break;
}
return answer;
}
public void ExponentialCreateFailsWithBadParameters(double lambda)
{
var n = new Exponential(lambda);
}
public void ValidateCumulativeDistribution(
[Values(0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity)] double lambda,
[Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity)] double x)
{
var n = new Exponential(lambda);
if (x >= 0.0)
{
Assert.AreEqual(1.0 - Math.Exp(-lambda * x), n.CumulativeDistribution(x));
}
else
{
Assert.AreEqual(0.0, n.CumulativeDistribution(x));
}
}
public void CanCreateExponential(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(lambda, n.Lambda);
}
public void ValidateDensityLn(double lambda, double x)
{
var n = new Exponential(lambda);
Assert.AreEqual(Math.Log(lambda) - (lambda * x), n.DensityLn(x));
}
public void ValidateMedian(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(Math.Log(2.0) / lambda, n.Median);
}
public void ValidateStdDev(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 / lambda, n.StdDev);
}
private void btnComparar_Click(object sender, EventArgs e)
{
double media = MathNet.Numerics.Statistics.ArrayStatistics.Mean(datos.ToArray());
switch (distribucionElegida)
{
case TipoDistribucion.continuaExponencial:
/*
* En el caso de haber elegido la distribucion exponencial, tenemos que:
*
* lambda(media) = 1 / (media muestral);
*
*/
//obtenemos el lambda para esta distribucion
double lambda = 1 / media;
//generamos la distribucion para el lambda dado:
Exponential exponencial = new Exponential(lambda);
//recorremos los intervalos para obtener los valores minimos y maximos, y asi calcular la frecuencia esperada
foreach (Intervalo intervalo in intervalos)
{
intervalo.frecuenciaEsperada = (exponencial.CumulativeDistribution(intervalo.limiteSuperior) - exponencial.CumulativeDistribution(intervalo.limiteInferior)) * datos.Count();
intervalo.frecuenciaEsperada = Math.Round(intervalo.frecuenciaEsperada, CANTIDAD_DECIMALES);
}
break;
case TipoDistribucion.continuaUniforme:
/*
* En el caso de haber elegido uniforme, tenemos que:
*
* FE = cantidad de datos de la muestra / cantidad de intervalos;
*
*/
//Entonces obtenemos este dato y se lo asignamos a todos los intervalos.
double frecuenciaEsperada = (double)datos.Count() / (double)intervalos.Count();
foreach (Intervalo intervalo in intervalos)
{
intervalo.frecuenciaEsperada = frecuenciaEsperada;
intervalo.frecuenciaEsperada = Math.Round(intervalo.frecuenciaEsperada, CANTIDAD_DECIMALES);
}
break;
case TipoDistribucion.continuaNormal:
/*
* Para distribucion normal tenemos:
*
* desviacion estandar (sigma) = raiz cuadrada de la media;
*
*/
//obtenemos la varianza
double varianza = MathNet.Numerics.Statistics.ArrayStatistics.Variance(datos.ToArray());
//calculamos la deviacion estandar
double desviacionEstandar = Math.Sqrt(varianza);
//creo la distribucion normal
MathNet.Numerics.Distributions.Normal normal = new MathNet.Numerics.Distributions.Normal(media, desviacionEstandar);
foreach (Intervalo intervalo in intervalos)
{
intervalo.frecuenciaEsperada = (normal.CumulativeDistribution(intervalo.limiteSuperior) - normal.CumulativeDistribution(intervalo.limiteInferior)) * datos.Count();
intervalo.frecuenciaEsperada = Math.Round(intervalo.frecuenciaEsperada, CANTIDAD_DECIMALES);
}
break;
}
graficar(true);
cboAlpha.Enabled = true;
cboTest.Enabled = true;
btnRealizarTest.Enabled = true;
}
public Exponential ConvertFromBase(Exponential value)
{
return(value / this.Factor); // 1000g -> 1kg
}
public Exponential ConvertToBase(Exponential value)
{
return(value * this.Factor); // 1kg -> 1000 g
}
public Prefix(string name, string symbol, Exponential factor)
{
this.Name = name;
this.Symbol = symbol;
this.Factor = factor;
}
//------------------------------------------------------------------------------------------------------------
public static float GetEasingFunction(Type easingFunction, float t)
{
// Quad
if (easingFunction == Type.EaseInQuad)
{
return(Quadratic.In(t));
}
if (easingFunction == Type.EaseOutQuad)
{
return(Quadratic.Out(t));
}
if (easingFunction == Type.EaseInOutQuad)
{
return(Quadratic.InOut(t));
}
// Cubic
if (easingFunction == Type.EaseInCubic)
{
return(Cubic.In(t));
}
if (easingFunction == Type.EaseOutCubic)
{
return(Cubic.Out(t));
}
if (easingFunction == Type.EaseInOutCubic)
{
return(Cubic.InOut(t));
}
// Quart
if (easingFunction == Type.EaseInQuart)
{
return(Quartic.In(t));
}
if (easingFunction == Type.EaseOutQuart)
{
return(Quartic.Out(t));;
}
if (easingFunction == Type.EaseInOutQuart)
{
return(Quartic.InOut(t));;
}
// Quint
if (easingFunction == Type.EaseInQuint)
{
return(Quintic.In(t));
}
if (easingFunction == Type.EaseOutQuint)
{
return(Quintic.Out(t));
}
if (easingFunction == Type.EaseInOutQuint)
{
return(Quintic.InOut(t));
}
// Sine
if (easingFunction == Type.EaseInSine)
{
return(Sinusoidal.In(t));
}
if (easingFunction == Type.EaseOutSine)
{
return(Sinusoidal.Out(t));
}
if (easingFunction == Type.EaseInOutSine)
{
return(Sinusoidal.InOut(t));
}
// Expo
if (easingFunction == Type.EaseInExpo)
{
return(Exponential.In(t));
}
if (easingFunction == Type.EaseOutExpo)
{
return(Exponential.Out(t));
}
if (easingFunction == Type.EaseInOutExpo)
{
return(Exponential.InOut(t));
}
// CirC
if (easingFunction == Type.EaseInCirc)
{
return(Circular.In(t));
}
if (easingFunction == Type.EaseOutCirc)
{
return(Circular.Out(t));
}
if (easingFunction == Type.EaseInOutCirc)
{
return(Circular.InOut(t));
}
// Linear
if (easingFunction == Type.Linear)
{
return(Linear(t));
}
// Bounce
if (easingFunction == Type.EaseInBounce)
{
return(Bounce.In(t));
}
if (easingFunction == Type.EaseOutBounce)
{
return(Bounce.Out(t));
}
if (easingFunction == Type.EaseInOutBounce)
{
return(Bounce.InOut(t));
}
// Back
if (easingFunction == Type.EaseInBack)
{
return(Back.In(t));
}
if (easingFunction == Type.EaseOutBack)
{
return(Back.Out(t));
}
if (easingFunction == Type.EaseInOutBack)
{
return(Back.InOut(t));
}
// Elastic
if (easingFunction == Type.EaseInElastic)
{
return(Elastic.In(t));
}
if (easingFunction == Type.EaseOutElastic)
{
return(Elastic.Out(t));
}
if (easingFunction == Type.EaseInOutElastic)
{
return(Elastic.InOut(t));
}
return(0);
}
public static int IndexWithRates(int length, Random rng) => length > 1 ? Exponential.IndexFromRate(length, rng.Next(100) + rng.NextDouble()) : 0;
public static Distribution FromDoc(Distribution existing, DocNode doc) {
// a single number means we want just a fixed value instead of a random distribution
if (doc.Type == DocNodeType.Scalar) {
var fixedValue = System.Convert.ToSingle(doc.StringValue);
if (existing != null && existing is Range) {
((Range)existing).Start = fixedValue;
((Range)existing).End = fixedValue;
return existing;
} else {
return new Range(fixedValue, fixedValue);
}
}
var first = doc[0].StringValue;
var resultType = typeof(Range);
int startingIndex = 1;
if (first == "vary") {
resultType = typeof(Vary);
} else if (first == "gaussian") {
resultType = typeof(Gaussian);
} else if (first == "binomial") {
resultType = typeof(Binomial);
} else if (first == "exponential") {
resultType = typeof(Exponential);
} else if (first == "range") {
resultType = typeof(Range);
} else {
// we haven't found a tag we know about, so assume that the first value is a number and it's a Range
startingIndex = 0;
}
// all these distributions take two floats as arguments, so let's parse those out first
float firstNum = System.Convert.ToSingle(doc[startingIndex].StringValue);
float secondNum = System.Convert.ToSingle(doc[startingIndex + 1].StringValue);
// set the numbers appropriate to the class
if (resultType == typeof(Range)) {
if (existing != null && existing is Range) {
((Range)existing).Start = firstNum;
((Range)existing).End = secondNum;
} else {
existing = new Range(firstNum, secondNum);
}
} else if (resultType == typeof(Vary)) {
if (existing != null && existing is Vary) {
((Vary)existing).Mean = firstNum;
((Vary)existing).Proportion = secondNum;
} else {
existing = new Vary(firstNum, secondNum);
}
} else if (resultType == typeof(Gaussian)) {
if (existing != null && existing is Gaussian) {
((Gaussian)existing).Mean = firstNum;
((Gaussian)existing).StdDev = secondNum;
} else {
existing = new Gaussian(firstNum, secondNum);
}
} else if (resultType == typeof(Binomial)) {
if (existing != null && existing is Binomial) {
((Binomial)existing).FlipProb = firstNum;
((Binomial)existing).Max = secondNum;
} else {
existing = new Binomial(firstNum, secondNum);
}
} else if (resultType == typeof(Exponential)) {
if (existing != null && existing is Exponential) {
((Exponential)existing).InvLambda = firstNum;
((Exponential)existing).Minimum = secondNum;
} else {
existing = new Exponential(firstNum, secondNum);
}
}
return existing;
}
public void ValidateMean(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 / lambda, n.Mean);
}
void Arrive()
{
Console.WriteLine($"{ClockTime}\tHello World #{Count}!");
Count++;
Schedule(Arrive, TimeSpan.FromHours(Exponential.Sample(DefaultRS, 1 / HourlyArrivalRate)));
}
public void ValidateSkewness(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(2.0, n.Skewness);
}
public void ValidateVariance(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 / (lambda * lambda), n.Variance);
}
public void ValidateMaximum()
{
var n = new Exponential(1.0);
Assert.AreEqual(Double.PositiveInfinity, n.Maximum);
}
public void ValidateStdDev(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 / lambda, n.StdDev);
}
public void CanSampleSequence()
{
var n = new Exponential(1.0);
var ied = n.Samples();
ied.Take(5).ToArray();
}
public void ValidateEntropy(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 - Math.Log(lambda), n.Entropy);
}
public void ValidateSkewness(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(2.0, n.Skewness);
}
public void ValidateMode(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(0.0, n.Mode);
}
public void CanCreateExponential([Values(0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity)] double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(lambda, n.Lambda);
}
public void ValidateMedian(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(Math.Log(2.0) / lambda, n.Median);
}
public void CanSetLambda(double lambda)
{
var n = new Exponential(1.0);
n.Lambda = lambda;
}
public void ValidateMinimum()
{
var n = new Exponential(1.0);
Assert.AreEqual(0.0, n.Minimum);
}
public void SetLambdaFailsWithNegativeLambda()
{
var n = new Exponential(1.0);
n.Lambda = -1.0;
}
public void ValidateMaximum()
{
var n = new Exponential(1.0);
Assert.AreEqual(double.PositiveInfinity, n.Maximum);
}
public void SetLambdaFailsWithNegativeLambda()
{
var n = new Exponential(1.0);
Assert.Throws<ArgumentOutOfRangeException>(() => n.Lambda = -1.0);
}
public void CanSample()
{
var n = new Exponential(1.0);
n.Sample();
}
public void ValidateVariance(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 / (lambda * lambda), n.Variance);
}
public void CanCreateExponential(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(lambda, n.Rate);
}
public void ValidateEntropy(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 - Math.Log(lambda), n.Entropy);
}
public void ValidateMean(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 / lambda, n.Mean);
}
public void ValidateMode(double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(0.0, n.Mode);
}
public void ValidateEntropy([Values(0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity)] double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(1.0 - Math.Log(lambda), n.Entropy);
}
public void ValidateMinimum()
{
var n = new Exponential(1.0);
Assert.AreEqual(0.0, n.Minimum);
}
public void ValidateMode([Values(0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity)] double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(0.0, n.Mode);
}
public void ValidateDensity(double lambda, double x)
{
var n = new Exponential(lambda);
if (x >= 0)
{
Assert.AreEqual(lambda * Math.Exp(-lambda * x), n.Density(x));
}
else
{
Assert.AreEqual(0.0, n.Density(lambda));
}
}
public void ValidateMedian([Values(0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity)] double lambda)
{
var n = new Exponential(lambda);
Assert.AreEqual(Math.Log(2.0) / lambda, n.Median);
}
public void CanSample()
{
var n = new Exponential(1.0);
n.Sample();
}
public void ValidateDensity(
[Values(0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity)] double lambda,
[Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity)] double x)
{
var n = new Exponential(lambda);
if (x >= 0)
{
Assert.AreEqual(lambda * Math.Exp(-lambda * x), n.Density(x));
}
else
{
Assert.AreEqual(0.0, n.Density(lambda));
}
}
public void ValidateCumulativeDistribution(double lambda, double x)
{
var n = new Exponential(lambda);
if (x >= 0.0)
{
Assert.AreEqual(1.0 - Math.Exp(-lambda * x), n.CumulativeDistribution(x));
}
else
{
Assert.AreEqual(0.0, n.CumulativeDistribution(x));
}
}
public void ValidateDensityLn(
[Values(0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity, 0.0, 0.1, 1.0, 10.0, Double.PositiveInfinity)] double lambda,
[Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.1, 0.1, 0.1, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity)] double x)
{
var n = new Exponential(lambda);
Assert.AreEqual(Math.Log(lambda) - (lambda * x), n.DensityLn(x));
}
public void ValidateToString()
{
var n = new Exponential(2.0);
Assert.AreEqual("Exponential(Lambda = 2)", n.ToString());
}
public void ValidateToString()
{
var n = new Exponential(2d);
Assert.AreEqual("Exponential(λ = 2)", n.ToString());
}
