public IVHat Calculate(
INormalFactory normalFactory,
IVHatResultElementFactory VHatResultElementFactory,
IVHatFactory VHatFactory,
IRNBCalculation RNBCalculation,
ItStarCalculation tStarCalculation,
IVHatResultElementCalculation VHatResultElementCalculation,
It t,
IΛ Λ,
IExpectedValueI expectedValueI,
IVarianceI varianceI,
Iυ2 υ2)
{
return(VHatFactory.Create(
Λ.Value
.Select(i => VHatResultElementCalculation.Calculate(
normalFactory,
VHatResultElementFactory,
RNBCalculation,
tStarCalculation,
i,
t,
expectedValueI,
varianceI,
υ2))
.ToImmutableList()));
}
public Iυ2ResultElement Calculate(
INormalFactory normalFactory,
Iυ2ResultElementFactory υ2ResultElementFactory,
IMRNBCalculation MRNBCalculation,
IRNBCalculation RNBCalculation,
IΛIndexElement ΛIndexElement,
It t,
IΩ Ω,
IExpectedValueI expectedValueI,
IVarianceI varianceI)
{
int MRNB = 0;
decimal υ2 = 0;
do
{
MRNB = MRNBCalculation.Calculate(
normalFactory,
RNBCalculation,
ΛIndexElement,
t,
expectedValueI,
varianceI,
υ2);
υ2 = (decimal)υ2 + (decimal)0.01;
} while (MRNB <= Ω.Value.Value.Value && υ2 <= 1);
return(υ2ResultElementFactory.Create(
ΛIndexElement,
υ2 - (decimal)0.01)); // Subtract 0.01 to account for last iteration of the do-while loop
}
public Iυ2 Calculate(
INormalFactory normalFactory,
Iυ2ResultElementFactory υ2ResultElementFactory,
Iυ2Factory υ2Factory,
IMRNBCalculation MRNBCalculation,
IRNBCalculation RNBCalculation,
Iυ2ResultElementCalculation υ2ResultElementCalculation,
It t,
IΛ Λ,
IΩ Ω,
IExpectedValueI expectedValueI,
IVarianceI varianceI)
{
return(υ2Factory.Create(
Λ.Value
.Select(i => υ2ResultElementCalculation.Calculate(
normalFactory,
υ2ResultElementFactory,
MRNBCalculation,
RNBCalculation,
i,
t,
Ω,
expectedValueI,
varianceI))
.ToImmutableList()));
}
public ItIndexElement Calculate(
INormalFactory normalFactory,
IRNBCalculation RNBCalculation,
IΛIndexElement ΛIndexElement,
It t,
IExpectedValueI expectedValueI,
IVarianceI varianceI,
Iυ2 υ2)
{
return(t.Value
.Select(i =>
KeyValuePair.Create(
i,
RNBCalculation.Calculate(
normalFactory,
i,
ΛIndexElement,
expectedValueI,
varianceI,
υ2.GetElementAtAsdecimal(
ΛIndexElement))))
.OrderBy(i => i.Value)
.LastOrDefault()
.Key);
}
public IEBSResultElement Calculate(
IEBSResultElementFactory EBSResultElementFactory,
ItIndexElement tIndexElement,
IΛIndexElement ΛIndexElement,
IΩ Ω,
IExpectedValueI ExpectedValueI,
IVarianceI VarianceI)
{
int Ω_tΛ = Ω.Value.Value.Value;
double ExpectedValueI_tΛ = (double)ExpectedValueI.GetElementAtAsdecimal(
tIndexElement,
ΛIndexElement);
double VarianceI_tΛ = (double)VarianceI.GetElementAtAsdecimal(
tIndexElement,
ΛIndexElement);
double lowerBound = Ω_tΛ + 0.5;
double upperBound = double.PositiveInfinity;
double value =
0.5
*
(Ω_tΛ - ExpectedValueI_tΛ)
*
(MathNet.Numerics.SpecialFunctions.Erf(
(lowerBound - ExpectedValueI_tΛ)
*
Math.Pow(Math.Sqrt(2 * VarianceI_tΛ), -1))
-
MathNet.Numerics.SpecialFunctions.Erf(
(upperBound - ExpectedValueI_tΛ)
*
Math.Pow(Math.Sqrt(2 * VarianceI_tΛ), -1)))
+
Math.Sqrt(VarianceI_tΛ)
*
Math.Pow(Math.Sqrt(2 * Math.PI), -1)
*
(Math.Exp(
-Math.Pow(lowerBound - ExpectedValueI_tΛ, 2)
*
Math.Pow(2 * VarianceI_tΛ, -1))
-
Math.Exp(
-Math.Pow(upperBound - ExpectedValueI_tΛ, 2)
*
Math.Pow(2 * VarianceI_tΛ, -1)));
return(EBSResultElementFactory.Create(
tIndexElement,
ΛIndexElement,
(decimal)value));
}
public IExpectedValueI Create(
ImmutableList <IExpectedValueIResultElement> value)
{
IExpectedValueI result = null;
try
{
result = new ExpectedValueI(
value);
}
catch (Exception exception)
{
this.Log.Error("Exception message: " + exception.Message + " and stacktrace " + exception.StackTrace);
}
return(result);
}
public IExpectedValueI Create(
ImmutableList <IExpectedValueIResultElement> value)
{
IExpectedValueI result = null;
try
{
result = new ExpectedValueI(
value);
}
catch (Exception exception)
{
this.Log.Error(
exception.Message,
exception);
}
return(result);
}
public IEBS Calculate(
IEBSResultElementFactory EBSResultElementFactory,
IEBSFactory EBSFactory,
IEBSResultElementCalculation EBSResultElementCalculation,
ItΛ tΛ,
IΩ Ω,
IExpectedValueI ExpectedValueI,
IVarianceI VarianceI)
{
return(EBSFactory.Create(
tΛ.Value
.Select(w => EBSResultElementCalculation.Calculate(
EBSResultElementFactory,
w.tIndexElement,
w.ΛIndexElement,
Ω,
ExpectedValueI,
VarianceI))
.ToImmutableList()));
}
public int Calculate(
INormalFactory normalFactory,
IRNBCalculation RNBCalculation,
IΛIndexElement ΛIndexElement,
It t,
IExpectedValueI expectedValueI,
IVarianceI varianceI,
decimal υ2)
{
return((int)Math.Ceiling(
t.Value
.Select(i => RNBCalculation.Calculate(
normalFactory,
i,
ΛIndexElement,
expectedValueI,
varianceI,
υ2))
.Max()));
}
public decimal Calculate(
INormalFactory normalFactory,
ItIndexElement tIndexElement,
IΛIndexElement ΛIndexElement,
IExpectedValueI expectedValueI,
IVarianceI varianceI,
decimal υ2)
{
// https://stackoverflow.com/questions/1662943/standard-normal-distribution-z-value-function-in-c-sharp
MathNet.Numerics.Distributions.Normal normal = (MathNet.Numerics.Distributions.Normal)normalFactory.Create();
return
((decimal)expectedValueI.GetElementAtAsdecimal(
tIndexElement,
ΛIndexElement)
+
(decimal)normal.CumulativeDistribution((double)(1 - υ2))
*
(decimal)Math.Sqrt(
(double)varianceI.GetElementAtAsdecimal(
tIndexElement,
ΛIndexElement)));
}
public IVHatResultElement Calculate(
INormalFactory normalFactory,
IVHatResultElementFactory VHatResultElementFactory,
IRNBCalculation RNBCalculation,
ItStarCalculation tStarCalculation,
IΛIndexElement ΛIndexElement,
It t,
IExpectedValueI expectedValueI,
IVarianceI varianceI,
Iυ2 υ2)
{
return(VHatResultElementFactory.Create(
ΛIndexElement,
varianceI.GetElementAtAsdecimal(
tStarCalculation.Calculate(
normalFactory,
RNBCalculation,
ΛIndexElement,
t,
expectedValueI,
varianceI,
υ2),
ΛIndexElement)));
}
public IΦHat Calculate(
IExpectedValueIResultElementCalculationFactory expectedValueIResultElementCalculationFactory,
IExpectedValueΦResultElementCalculationFactory expectedValueΦResultElementCalculationFactory,
IVarianceIResultElementCalculationFactory varianceIResultElementCalculationFactory,
IVarianceΦResultElementCalculationFactory varianceΦResultElementCalculationFactory,
IVHatResultElementCalculationFactory VHatResultElementCalculationFactory,
Iυ2ResultElementCalculationFactory υ2ResultElementCalculationFactory,
IΦHatResultElementCalculationFactory ΦHatResultElementCalculationFactory,
IExpectedValueICalculationFactory expectedValueICalculationFactory,
IExpectedValueΦCalculationFactory expectedValueΦCalculationFactory,
IMRNBCalculationFactory MRNBCalculationFactory,
IRNBCalculationFactory RNBCalculationFactory,
ItStarCalculationFactory tStarCalculationFactory,
IVarianceICalculationFactory varianceICalculationFactory,
IVarianceΦCalculationFactory varianceΦCalculationFactory,
IVHatCalculationFactory VHatCalculationFactory,
Iυ2CalculationFactory υ2CalculationFactory,
INormalFactory normalFactory,
IExpectedValueIResultElementFactory expectedValueIResultElementFactory,
IExpectedValueΦResultElementFactory expectedValueΦResultElementFactory,
IVarianceIResultElementFactory varianceIResultElementFactory,
IVarianceΦResultElementFactory varianceΦResultElementFactory,
IVHatResultElementFactory VHatResultElementFactory,
Iυ2ResultElementFactory υ2ResultElementFactory,
IΦHatResultElementFactory ΦHatResultElementFactory,
IExpectedValueIFactory expectedValueIFactory,
IExpectedValueΦFactory expectedValueΦFactory,
IVarianceIFactory varianceIFactory,
IVarianceΦFactory varianceΦFactory,
IVHatFactory VHatFactory,
Iυ2Factory υ2Factory,
IΦHatFactory ΦHatFactory,
Il l,
It t,
IΛ Λ,
IslΛ slΛ,
Ist st,
ItΛ tΛ,
IL L,
Ip p,
Iμ μ,
Iσ σ,
IΩ Ω,
Iz z)
{
// ExpectedValueΦ
IExpectedValueΦ expectedValueΦ = expectedValueΦCalculationFactory.Create()
.Calculate(
expectedValueΦResultElementFactory,
expectedValueΦFactory,
expectedValueΦResultElementCalculationFactory.Create(),
l,
t,
slΛ,
L,
p,
μ);
// VarianceΦ
IVarianceΦ varianceΦ = varianceΦCalculationFactory.Create()
.Calculate(
varianceΦResultElementFactory,
varianceΦFactory,
varianceΦResultElementCalculationFactory.Create(),
l,
t,
slΛ,
L,
p,
μ,
σ);
// ExpectedValueI
IExpectedValueI expectedValueI = expectedValueICalculationFactory.Create()
.Calculate(
expectedValueIResultElementFactory,
expectedValueIFactory,
expectedValueIResultElementCalculationFactory.Create(),
l,
t,
st,
tΛ,
expectedValueΦ,
z);
// VarianceI
IVarianceI varianceI = varianceICalculationFactory.Create()
.Calculate(
varianceIResultElementFactory,
varianceIFactory,
varianceIResultElementCalculationFactory.Create(),
l,
t,
st,
tΛ,
varianceΦ,
z);
// υ2
Iυ2 υ2 = υ2CalculationFactory.Create()
.Calculate(
normalFactory,
υ2ResultElementFactory,
υ2Factory,
MRNBCalculationFactory.Create(),
RNBCalculationFactory.Create(),
υ2ResultElementCalculationFactory.Create(),
t,
Λ,
Ω,
expectedValueI,
varianceI);
// VHat
IVHat VHat = VHatCalculationFactory.Create()
.Calculate(
normalFactory,
VHatResultElementFactory,
VHatFactory,
RNBCalculationFactory.Create(),
tStarCalculationFactory.Create(),
VHatResultElementCalculationFactory.Create(),
t,
Λ,
expectedValueI,
varianceI,
υ2);
return(this.Calculate(
normalFactory,
ΦHatResultElementFactory,
ΦHatFactory,
ΦHatResultElementCalculationFactory.Create(),
slΛ,
expectedValueΦ,
varianceΦ,
VHat,
υ2));
}
