using System;

using System.Collections.Generic;

using System.Linq;

​

class Program

{

    static void Main(string[] args)

    {

        double[] data = new double[] {75, 66.11, 37.18, 82.64, 105, 50, 40.24, 60, 49.59, 75, 169948, 42};

        double Q1 = Percentile(data, 25);

        double Q3 = Percentile(data, 75);

        double IQR = Q3 - Q1;

        double[] filteredData = data.Where(x => Q1 - 1.5 * IQR <= x && x <= Q3 + 1.5 * IQR).ToArray();

        double initialEstimate = filteredData.Average();

        double initialErrorEstimate = StandardDeviation(filteredData) / Math.Sqrt(filteredData.Length);

        double measurementError = initialErrorEstimate;

​

        var (estimates, errors) = KalmanFilterV2(filteredData, initialEstimate, initialErrorEstimate, measurementError);

​

        double estimatedCost = estimates.Last();

        double estimatedError = Math.Sqrt(errors.Last());

        double estimatedDiff = estimatedCost * estimatedError;

        // double estimatedMin = Math.Max(estimatedCost - estimatedDiff, 0);

        // double estimatedMax = estimatedCost + estimatedDiff;

        double estimatedMin = Q1;

        double estimatedMax = Q3;

​

        double intervalWidth = estimatedMax - estimatedMin;

        double maxIntervalWidth = initialEstimate;

​

        int defaultSamples = 3;

        double intervalWidthFactor = 0.2;

        double samplesFactor = 0.33;

​

        double confidenceIndex = 5 * (1 - intervalWidthFactor * intervalWidth / maxIntervalWidth * Math.Sqrt(samplesFactor * defaultSamples / filteredData.Length));

        confidenceIndex = Math.Max(0, Math.Min(confidenceIndex, 5));

​

        Console.WriteLine("Estimated cost: " + estimatedCost);

        Console.WriteLine("Estimated error: " + estimatedError);

        Console.WriteLine("Estimated minimum: " + estimatedMin);

        Console.WriteLine("Estimated maximum: " + estimatedMax);

        Console.WriteLine("IQR minimum: " + Q1);

        Console.WriteLine("IQR maximum: " + Q3);

        Console.WriteLine("Confidence (A): " + confidenceIndex * 0.33);

        Console.WriteLine("Confidence (AR): " + confidenceIndex * 0.8);

        Console.WriteLine("Confidence (AEs): " + confidenceIndex * 0.5);

        Console.WriteLine("Confidence (AEl): " + confidenceIndex * 0.66);

        Console.WriteLine("Confidence (AREs): " + confidenceIndex * 0.9);

        Console.WriteLine("Confidence (AREl): " + confidenceIndex);

    }

​

    static (List<double>, List<double>) KalmanFilterV2(double[] data, double estimate, double errorEstimate, double measurementError)

    {

        List<double> estimates = new List<double>();

        List<double> errors = new List<double>();

​

        foreach (double measurement in data)

        {

            // prediction step

            double prediction = estimate;

            double errorPrediction = errorEstimate;

​

            // update step

            double kalmanGain = errorPrediction / (errorPrediction + measurementError);

            estimate = prediction + kalmanGain * (measurement - prediction);

            errorEstimate = (1 - kalmanGain) * errorPrediction;

​

            estimates.Add(estimate);

            errors.Add(errorEstimate);

        }

​

        return (estimates, errors);

    }

​

    static double Percentile(double[] sequence, double percentile)

    {

        Array.Sort(sequence);

        int N = sequence.Length;

        double n = (N - 1) * percentile / 100.0 + 1;

        if (n <= 1) return sequence[0];

        else if (n >= N) return sequence[N - 1];

        else

        {

            int k = (int)n;

            double d = n - k;

            return sequence[k - 1] + d * (sequence[k] - sequence[k - 1]);

        }

    }

​

​

    static double StandardDeviation(double[] values)

    {

        double avg = values.Average();

        return Math.Sqrt(values.Average(v => Math.Pow(v - avg, 2)));

    }

}

​