public IEBSResultElement Calculate(
            IEBSResultElementFactory EBSResultElementFactory,
            IdIndexElement dIndexElement,
            Iw w,
            IBEDS BEDS,
            Iμ μ,
            IVariance Variance)
        {
            int BEDS_d = BEDS.Value.Value.Value;

            double ExpectedValue_d = w.Value
                                     .Select(y => (double)μ.GetElementAtAsdecimal(
                                                 y,
                                                 dIndexElement))
                                     .Sum();

            double Variance_d = w.Value
                                .Select(y => (double)Variance.GetElementAtAsdecimal(
                                            y,
                                            dIndexElement))
                                .Sum();

            double lowerBound = BEDS_d + 0.5;

            double upperBound = double.PositiveInfinity;

            double value =
                0.5
                *
                (BEDS_d - ExpectedValue_d)
                *
                (MathNet.Numerics.SpecialFunctions.Erf(
                     (lowerBound - ExpectedValue_d)
                     *
                     Math.Pow(Math.Sqrt(2 * Variance_d), -1))
                 -
                 MathNet.Numerics.SpecialFunctions.Erf(
                     (upperBound - ExpectedValue_d)
                     *
                     Math.Pow(Math.Sqrt(2 * Variance_d), -1)))
                +
                Math.Sqrt(Variance_d)
                *
                Math.Pow(Math.Sqrt(2 * Math.PI), -1)
                *
                (Math.Exp(
                     -Math.Pow(lowerBound - ExpectedValue_d, 2)
                     *
                     Math.Pow(2 * Variance_d, -1))
                 -
                 Math.Exp(
                     -Math.Pow(upperBound - ExpectedValue_d, 2)
                     *
                     Math.Pow(2 * Variance_d, -1)));

            return(EBSResultElementFactory.Create(
                       dIndexElement,
                       (decimal)value));
        }
        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 IEBSResultElementFactory CreateEBSResultElementFactory()
        {
            IEBSResultElementFactory factory = null;

            try
            {
                factory = new EBSResultElementFactory();
            }
            catch (Exception exception)
            {
                this.Log.Error("Exception message: " + exception.Message + " and stacktrace " + exception.StackTrace);
            }

            return(factory);
        }
Пример #4
0
        public IEBSResultElementFactory CreateEBSResultElementFactory()
        {
            IEBSResultElementFactory factory = null;

            try
            {
                factory = new EBSResultElementFactory();
            }
            catch (Exception exception)
            {
                this.Log.Error(
                    exception.Message,
                    exception);
            }

            return(factory);
        }
Пример #5
0
 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()));
 }
Пример #6
0
 public IEBS Calculate(
     IEBSResultElementFactory EBSResultElementFactory,
     IEBSFactory EBSFactory,
     IEBSResultElementCalculation EBSResultElementCalculation,
     Id d,
     Iw w,
     IBEDS BEDS,
     Iμ μ,
     IVariance Variance)
 {
     return(EBSFactory.Create(
                d.Value
                .Select(y => EBSResultElementCalculation.Calculate(
                            EBSResultElementFactory,
                            y,
                            w,
                            BEDS,
                            μ,
                            Variance))
                .ToImmutableList()));
 }