/// <summary>
        ///   Creates a new test for two ROC curves.
        /// </summary>
        ///
        /// <param name="curve1">The first ROC curve.</param>
        /// <param name="curve2">The second ROC curve.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two areas.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public TwoReceiverOperatingCurveTest(ReceiverOperatingCharacteristic curve1, ReceiverOperatingCharacteristic curve2,
                                             double hypothesizedDifference = 0, TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            this.Curve1 = curve1;
            this.Curve2 = curve2;

            double[] Vx1 = curve1.NegativeAccuracies;
            double[] Vy1 = curve1.PositiveAccuracies;

            double[] Vx2 = curve2.NegativeAccuracies;
            double[] Vy2 = curve2.PositiveAccuracies;

            double covx = Measures.Covariance(Vx1, Vx2);
            double covy = Measures.Covariance(Vy1, Vy2);
            double cov  = covx / Vx1.Length + covy / Vy1.Length;

            this.EstimatedValue1        = curve1.Area;
            this.EstimatedValue2        = curve2.Area;
            this.ObservedDifference     = EstimatedValue1 - EstimatedValue2;
            this.HypothesizedDifference = hypothesizedDifference;

            this.Variance1 = curve1.Variance;
            this.Variance2 = curve2.Variance;

            this.OverallVariance = Variance1 + Variance2 - 2 * cov;
            this.StandardError   = System.Math.Sqrt(OverallVariance);

            // Compute Z statistic
            double z = (ObservedDifference - HypothesizedDifference) / StandardError;

            Compute(z, alternate);
        }
        public TwoSampleHypothesisTestResult TestHypothesis(IEnumerable <double> sample1, IEnumerable <double> sample2, double hypothesizedDifference,
                                                            TwoSampleHypothesis alternateHypothesis, double alpha)
        {
            var sample1Collection = sample1 as ICollection <double> ?? sample1.ToArray();
            var sample2Collection = sample2 as ICollection <double> ?? sample2.ToArray();

            ITwoSampleNormalDistributionHypothesisTest test;

            if (sample1Collection.Count < 30 ||
                sample2Collection.Count < 30)
            {
                test = new TwoSampleTTestHypothesisTest();
            }
            else
            {
                test = new TwoSampleZTestHypothesisTest();
            }

            return(test
                   .TestHypothesis(
                       sample1Collection,
                       sample2Collection,
                       hypothesizedDifference,
                       alternateHypothesis,
                       alpha));
        }
 public static bool RunConcurrentPerformanceComparison(int numIterations, int degreeParallelism,
     Action firstOperation, Action secondOperation, double hypothesizedDifference = 0,
     TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent, bool outputDetails = false)
 {
     return RunConcurrentPerformanceComparison(numIterations, degreeParallelism, "first", firstOperation,
         "second", secondOperation, hypothesizedDifference, hypothesis, outputDetails);
 }
Пример #4
0
        /// <summary>
        ///   Tests whether two samples comes from the
        ///   same distribution without assuming normality.
        /// </summary>
        ///
        /// <param name="sample1">The first sample.</param>
        /// <param name="sample2">The second sample.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// <param name="exact">True to compute the exact distribution. May require a significant
        ///   amount of processing power for large samples (n > 12). If left at null, whether to
        ///   compute the exact or approximate distribution will depend on the number of samples.
        ///   Default is null.</param>
        /// <param name="adjustForTies">Whether to account for ties when computing the
        ///   rank statistics or not. Default is true.</param>
        ///
        public MannWhitneyWilcoxonTest(double[] sample1, double[] sample2,
                                       TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent,
                                       bool?exact = null, bool adjustForTies = true)
        {
            this.NumberOfSamples1 = sample1.Length;
            this.NumberOfSamples2 = sample2.Length;
            int n = NumberOfSamples1 + NumberOfSamples2;

            // Concatenate both samples and rank them
            double[] samples = sample1.Concatenate(sample2);
            double[] rank    = samples.Rank(adjustForTies: true);

            // Split the rankings back and sum
            Rank1 = rank.Get(0, NumberOfSamples1);
            Rank2 = rank.Get(NumberOfSamples1, 0);

            // Compute rank sum statistic
            this.RankSum1 = Rank1.Sum();
            this.RankSum2 = Rank2.Sum();

            // It is not necessary to compute the sum for both ranks. The sum of ranks in the second
            // sample can be determined from the first, since the sum of all the ranks equals n(n+1)/2
            Accord.Diagnostics.Debug.Assert(RankSum2 == n * (n + 1) / 2 - RankSum1);

            // The U statistic can be obtained from the sum of the ranks in the sample,
            // minus the smallest value it can take (i.e. minus (n1 * (n1 + 1)) / 2.0),
            // meaning there is an wasy way to convert from W to U:

            // Compute Mann-Whitney's U statistic from the rank sum
            // as in Zar, Jerrold H. Biostatistical Analysis, 1998:
            this.Statistic1 = RankSum1 - (NumberOfSamples1 * (NumberOfSamples1 + 1)) / 2.0; // U1
            this.Statistic2 = RankSum2 - (NumberOfSamples2 * (NumberOfSamples2 + 1)) / 2.0; // U2

            // Again, it would not be necessary to compute U2 due the relation:
            Accord.Diagnostics.Debug.Assert(Statistic1 + Statistic2 == NumberOfSamples1 * NumberOfSamples2);

            Accord.Diagnostics.Debug.Assert(Statistic1 == MannWhitneyDistribution.MannWhitneyU(Rank1));
            Accord.Diagnostics.Debug.Assert(Statistic2 == MannWhitneyDistribution.MannWhitneyU(Rank2));

            // http://users.sussex.ac.uk/~grahamh/RM1web/WilcoxonHandoout2011.pdf
            // https://onlinecourses.science.psu.edu/stat464/node/38
            // http://www.real-statistics.com/non-parametric-tests/wilcoxon-rank-sum-test/
            // http://personal.vu.nl/R.Heijungs/QM/201516/stat/bs/documents/Supplement%2016B%20-%20Wilcoxon%20Mann-Whitney%20Small%20Sample%20Test.pdf
            // http://www.real-statistics.com/non-parametric-tests/wilcoxon-rank-sum-test/wilcoxon-rank-sum-exact-test/

            // The smaller value of U1 and U2 is the one used when using significance tables
            this.Statistic = (NumberOfSamples1 < NumberOfSamples2) ? Statistic1 : Statistic2;

            this.Hypothesis = alternate;
            this.Tail       = (DistributionTail)alternate;

            this.StatisticDistribution = new MannWhitneyDistribution(Rank1, Rank2, exact)
            {
                Correction = (Tail == DistributionTail.TwoTail) ? ContinuityCorrection.Midpoint : ContinuityCorrection.KeepInside
            };

            this.PValue = StatisticToPValue(Statistic);

            this.OnSizeChanged();
        }
Пример #5
0
        /// <summary>
        ///   Constructs a Z test.
        /// </summary>
        ///
        /// <param name="sample1">The first data sample.</param>
        /// <param name="sample2">The second data sample.</param>
        /// <param name="hypothesizedDifference">The hypothesized sample difference.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public TwoSampleZTest(double[] sample1, double[] sample2, double hypothesizedDifference = 0,
                              TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            int samples1 = sample1.Length;
            int samples2 = sample2.Length;

            if (samples1 < 30 || samples2 < 30)
            {
                System.Diagnostics.Trace.TraceWarning(
                    "Warning: running a Z test for less than 30 samples. Consider running a Student's T Test instead.");
            }

            double mean1 = Tools.Mean(sample1);
            double mean2 = Tools.Mean(sample2);

            double var1 = Tools.Variance(sample1, mean1);
            double var2 = Tools.Variance(sample2, mean2);

            double sqStdError1 = var1 / sample1.Length;
            double sqStdError2 = var2 / sample2.Length;

            this.Compute(mean1, mean2, sqStdError1, sqStdError2, hypothesizedDifference, alternate);

            this.power(var1, var2, sample1.Length, sample2.Length);
        }
Пример #6
0
        /// <summary>
        ///   Tests whether two samples comes from the
        ///   same distribution without assuming normality.
        /// </summary>
        ///
        /// <param name="sample1">The first sample.</param>
        /// <param name="sample2">The second sample.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public MannWhitneyWilcoxonTest(double[] sample1, double[] sample2,
                                       TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            int n1 = sample1.Length;
            int n2 = sample2.Length;
            int n  = n1 + n2;

            // Concatenate both samples and rank them
            double[] samples = sample1.Concatenate(sample2);
            double[] rank    = Accord.Statistics.Tools.Rank(samples);

            // Split the rankings back and sum
            Rank1 = rank.Submatrix(0, n1 - 1);
            Rank2 = rank.Submatrix(n1, n - 1);

            double t1 = RankSum1 = Rank1.Sum();
            double t2 = RankSum2 = Rank2.Sum();

            // Estimated values for t under the null
            double t1max = n1 * n2 + (n1 * (n1 + 1)) / 2.0;
            double t2max = n1 * n2 + (n2 * (n2 + 1)) / 2.0;

            // Diff in observed t and estimated t
            double u1 = Statistic1 = t1max - t1;
            double u2 = Statistic2 = t2max - t2;

            double hypothesizedValue = (n1 * n2) / 2.0;

            Compute(u1, rank, n1, n2, alternate);
        }
Пример #7
0
 /// <summary>
 ///     Tests whether the means of two samples are different.
 /// </summary>
 /// <param name="mean1">The first sample's mean.</param>
 /// <param name="mean2">The second sample's mean.</param>
 /// <param name="var1">The first sample's variance.</param>
 /// <param name="var2">The second sample's variance.</param>
 /// <param name="samples1">The number of observations in the first sample.</param>
 /// <param name="samples2">The number of observations in the second sample.</param>
 /// <param name="assumeEqualVariances">True assume equal variances, false otherwise. Default is true.</param>
 /// <param name="hypothesizedDifference">The hypothesized sample difference.</param>
 /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
 public TwoSampleTTest(double mean1, double var1, int samples1, double mean2, double var2, int samples2,
                       bool assumeEqualVariances     = true, double hypothesizedDifference = 0,
                       TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
 {
     Compute(mean1, var1, samples1, mean2, var2, samples2,
             hypothesizedDifference, assumeEqualVariances, alternate);
 }
 public static bool RunConcurrentPerformanceComparison(int numIterations, int degreeParallelism,
                                                       Action firstOperation, Action secondOperation, double hypothesizedDifference = 0,
                                                       TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent, bool outputDetails = false)
 {
     return(RunConcurrentPerformanceComparison(numIterations, degreeParallelism, "first", firstOperation,
                                               "second", secondOperation, hypothesizedDifference, hypothesis, outputDetails));
 }
Пример #9
0
        /// <summary>
        ///   Computes the two sample sign test.
        /// </summary>
        ///
        protected void Compute(int positive, int total, TwoSampleHypothesis alternate)
        {
            this.Hypothesis = alternate;

            // The underlying test is to check whether the probability
            // value from the samples are higher than or lesser than 0.5,
            // thus the actual Binomial test hypothesis is inverted:

            OneSampleHypothesis binomialHypothesis;

            switch (alternate)
            {
            case TwoSampleHypothesis.ValuesAreDifferent:
                binomialHypothesis = OneSampleHypothesis.ValueIsDifferentFromHypothesis; break;

            case TwoSampleHypothesis.FirstValueIsGreaterThanSecond:
                binomialHypothesis = OneSampleHypothesis.ValueIsSmallerThanHypothesis; break;

            case TwoSampleHypothesis.FirstValueIsSmallerThanSecond:
                binomialHypothesis = OneSampleHypothesis.ValueIsGreaterThanHypothesis; break;

            default: throw new InvalidOperationException();
            }


            base.Compute(positive, total, 0.5, binomialHypothesis);
        }
Пример #10
0
        /// <summary>
        ///   Creates a new sign test for two samples.
        /// </summary>
        ///
        /// <param name="sample1">The first sample of observations.</param>
        /// <param name="sample2">The second sample of observations.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public TwoSampleSignTest(double[] sample1, double[] sample2, TwoSampleHypothesis alternate)
        {
            if (sample1.Length != sample2.Length)
            {
                throw new DimensionMismatchException("sample2", "Both samples should be of the same size.");
            }

            int positive = 0;
            int negative = 0;

            for (int i = 0; i < sample1.Length; i++)
            {
                double d = sample2[i] - sample1[i];

                if (d > 0)
                {
                    positive++;
                }
                else if (d < 0)
                {
                    negative++;
                }
            }


            Compute(positive, positive + negative, alternate);
        }
        /// <summary>
        ///   Creates a new test for two ROC curves.
        /// </summary>
        /// 
        /// <param name="curve1">The first ROC curve.</param>
        /// <param name="curve2">The second ROC curve.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two areas.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public TwoReceiverOperatingCurveTest(ReceiverOperatingCharacteristic curve1, ReceiverOperatingCharacteristic curve2,
            double hypothesizedDifference = 0, TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            this.Curve1 = curve1;
            this.Curve2 = curve2;

            double[] Vx1 = curve1.NegativeAccuracies;
            double[] Vy1 = curve1.PositiveAccuracies;

            double[] Vx2 = curve2.NegativeAccuracies;
            double[] Vy2 = curve2.PositiveAccuracies;

            double covx = Measures.Covariance(Vx1, Vx2);
            double covy = Measures.Covariance(Vy1, Vy2);
            double cov = covx / Vx1.Length + covy / Vy1.Length;

            this.EstimatedValue1 = curve1.Area;
            this.EstimatedValue2 = curve2.Area;
            this.ObservedDifference = EstimatedValue1 - EstimatedValue2;
            this.HypothesizedDifference = hypothesizedDifference;

            this.Variance1 = curve1.Variance;
            this.Variance2 = curve2.Variance;

            this.OverallVariance = Variance1 + Variance2 - 2 * cov;
            this.StandardError = System.Math.Sqrt(OverallVariance);

            // Compute Z statistic
            double z = (ObservedDifference - HypothesizedDifference) / StandardError;

            Compute(z, alternate);
        }
Пример #12
0
        /// <summary>
        ///   Creates a new paired t-test.
        /// </summary>
        ///
        /// <param name="sample1">The observations in the first sample.</param>
        /// <param name="sample2">The observations in the second sample.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public PairedTTest(double[] sample1, double[] sample2,
                           TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            if (sample1.Length != sample2.Length)
            {
                throw new DimensionMismatchException("sample2", "Paired samples must have the same size.");
            }

            int n = sample1.Length;

            double[] delta = new double[sample1.Length];
            for (int i = 0; i < delta.Length; i++)
            {
                delta[i] = sample1[i] - sample2[i];
            }

            double mean = delta.Mean();
            double std  = delta.StandardDeviation();

            StandardError      = std / Math.Sqrt(n);
            ObservedDifference = mean;
            Mean1 = sample1.Mean();
            Mean2 = sample2.Mean();

            SampleSize            = n;
            Statistic             = ObservedDifference / StandardError;
            StatisticDistribution = new TDistribution(n - 1);

            this.Hypothesis = alternate;
            this.Tail       = (DistributionTail)alternate;
            this.PValue     = StatisticToPValue(Statistic);

            this.OnSizeChanged();
        }
Пример #13
0
        /// <summary>
        ///   Creates a new Two-Table Mean Kappa test.
        /// </summary>
        ///
        /// <param name="matrices1">The first group of contingency tables.</param>
        /// <param name="matrices2">The second  group of contingency tables.</param>
        /// <param name="assumeEqualVariances">True to assume equal variances, false otherwise. Default is true.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two average Kappa values.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public TwoAverageKappaTest(GeneralConfusionMatrix[] matrices1, GeneralConfusionMatrix[] matrices2,
                                   double hypothesizedDifference = 0, bool assumeEqualVariances = true,
                                   TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            double[] kappas1 = new double[matrices1.Length];
            for (int i = 0; i < matrices1.Length; i++)
            {
                kappas1[i] = matrices1[i].Kappa;
            }

            double[] kappas2 = new double[matrices1.Length];
            for (int i = 0; i < matrices2.Length; i++)
            {
                kappas2[i] = matrices2[i].Kappa;
            }

            double meanKappa1 = kappas1.Mean();
            double meanKappa2 = kappas2.Mean();

            Variance1 = kappas1.Variance(meanKappa1);
            Variance2 = kappas2.Variance(meanKappa2);

            int kappaSamples1 = matrices1.Length;
            int kappaSamples2 = matrices2.Length;

            base.Compute(
                meanKappa1, Variance1, kappaSamples1,
                meanKappa2, Variance2, kappaSamples2,
                hypothesizedDifference, assumeEqualVariances, alternate);
        }
Пример #14
0
        /// <summary>
        ///   Creates a new Z-Test for two sample proportions.
        /// </summary>
        /// 
        /// <param name="proportion1">The proportion of success observations in the first sample.</param>
        /// <param name="sampleSize1">The total number of observations in the first sample.</param>
        /// <param name="proportion2">The proportion of success observations in the second sample.</param>
        /// <param name="sampleSize2">The total number of observations in the second sample.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// 
        public TwoProportionZTest(double proportion1, int sampleSize1, double proportion2, int sampleSize2,
            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            int x1 = (int)Math.Round(proportion1 * sampleSize1);
            int x2 = (int)Math.Round(proportion2 * sampleSize2);

            Compute(x1, sampleSize1, x2, sampleSize2, alternate);
        }
Пример #15
0
        /// <summary>
        ///     Tests whether the means of two samples are different.
        /// </summary>
        /// <param name="sample1">The first sample.</param>
        /// <param name="sample2">The second sample.</param>
        /// <param name="hypothesizedDifference">The hypothesized sample difference.</param>
        /// <param name="assumeEqualVariances">True to assume equal variances, false otherwise. Default is true.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        public TwoSampleZTest(DescriptiveResult sample1, DescriptiveResult sample2,
                              double hypothesizedDifference = 0, TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            // References: http://en.wikipedia.org/wiki/Student's_t-test#Worked_examples

            Compute(sample1.Mean, sample2.Mean, sample1.Variance / sample1.Count, sample2.Variance / sample2.Count,
                    hypothesizedDifference, alternate);
        }
Пример #16
0
        /// <summary>
        ///   Creates a new Z-Test for two sample proportions.
        /// </summary>
        ///
        /// <param name="proportion1">The proportion of success observations in the first sample.</param>
        /// <param name="sampleSize1">The total number of observations in the first sample.</param>
        /// <param name="proportion2">The proportion of success observations in the second sample.</param>
        /// <param name="sampleSize2">The total number of observations in the second sample.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public TwoProportionZTest(double proportion1, int sampleSize1, double proportion2, int sampleSize2,
                                  TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            int x1 = (int)Math.Round(proportion1 * sampleSize1);
            int x2 = (int)Math.Round(proportion2 * sampleSize2);

            Compute(x1, sampleSize1, x2, sampleSize2, alternate);
        }
Пример #17
0
 public BothLatencyValidator(
     double alpha, TwoSampleHypothesis alternateHypothesis,
     // TODO: P2 - per the link, appears this may be the number of standard deviations? http://accord-framework.net/docs/html/T_Accord_Statistics_Testing_Power_TwoSampleTTestPowerAnalysis.htm
     double minimumDetectableDifferenceDesired = 0.00001, // Some number larger than 0
     double testStatisticalPower = 0.8                    // the test power that we want. 0.8 is a standard - 0.9 is more conservative -- 1 - probability of rejecting the null hypothesis when the null hypothesis is actually false
     )
     : this(alpha, alternateHypothesis, 0.Percent(), minimumDetectableDifferenceDesired, testStatisticalPower)
 {
 }
Пример #18
0
        /// <summary>
        ///     Computes the Z test.
        /// </summary>
        protected void Compute(double statistic, TwoSampleHypothesis alternate)
        {
            Statistic             = statistic;
            StatisticDistribution = NormalDistribution.Standard;

            Hypothesis = alternate;

            PValue = StatisticToPValue(Statistic);
        }
Пример #19
0
        /// <summary>
        ///   Computes the F-test.
        /// </summary>
        ///
        protected void Compute(double statistic, int d1, int d2, TwoSampleHypothesis alternate)
        {
            this.Statistic             = statistic;
            this.StatisticDistribution = new FDistribution(d1, d2);

            this.Hypothesis = alternate;
            this.Tail       = (DistributionTail)alternate;
            this.PValue     = StatisticToPValue(Statistic);
            this.OnSizeChanged();
        }
Пример #20
0
        /// <summary>
        ///   Computes the Mann-Whitney-Wilcoxon test.
        /// </summary>
        ///
        protected void Compute(double statistic, double[] ranks, int n1, int n2, TwoSampleHypothesis alternate)
        {
            this.Statistic             = statistic;
            this.StatisticDistribution = new MannWhitneyDistribution(ranks, n1, n2);
            this.Hypothesis            = alternate;
            this.Tail   = (DistributionTail)alternate;
            this.PValue = StatisticToPValue(Statistic);

            this.OnSizeChanged();
        }
Пример #21
0
        /// <summary>
        ///   Computes the Z test.
        /// </summary>
        ///
        protected void Compute(double observedDifference, double hypothesizedDifference,
                               double standardError, TwoSampleHypothesis alternate)
        {
            this.ObservedDifference     = observedDifference;
            this.HypothesizedDifference = hypothesizedDifference;
            this.StandardError          = standardError;

            // Compute Z statistic
            double z = (ObservedDifference - HypothesizedDifference) / StandardError;

            Compute(z, alternate);
        }
Пример #22
0
        public GeneralHypothesisTest(string firstLabel, DescriptiveResult sample1, string secondLabel,
                                     DescriptiveResult sample2, double hypothesizedDifference = 0,
                                     TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            int samples1 = sample1.Count;
            int samples2 = sample2.Count;

            HypothesizedDifference = Math.Abs(hypothesizedDifference);

            var s1 = new SampleInfo
            {
                Name   = firstLabel,
                Count  = sample1.Count,
                Mean   = sample1.Mean,
                StdDev = sample1.StdDev
            };

            var s2 = new SampleInfo
            {
                Name   = secondLabel,
                Count  = sample2.Count,
                Mean   = sample2.Mean,
                StdDev = sample2.StdDev
            };

            Result = new ComparisonResult
            {
                FirstSample            = s1,
                SecondSample           = s2,
                Hypothesis             = alternate,
                HypothesizedDifference = HypothesizedDifference
            };


            if (samples1 < 30 || samples2 < 30)
            {
                _tTest                    = new TwoSampleTTest(sample1, sample2, false, HypothesizedDifference, alternate);
                Result.Confidence         = _tTest.Confidence;
                Result.ObservedDifference = _tTest.ObservedDifference;
                Result.Significant        = _tTest.Significant;
                Result.Size               = _tTest.Size;
                Result.StandardError      = _tTest.StandardError;
            }
            else
            {
                _zTest                    = new TwoSampleZTest(sample1, sample2, HypothesizedDifference, alternate);
                Result.Confidence         = _zTest.Confidence;
                Result.ObservedDifference = _zTest.ObservedDifference;
                Result.Significant        = _zTest.Significant;
                Result.Size               = _zTest.Size;
                Result.StandardError      = _zTest.StandardError;
            }
        }
Пример #23
0
        /// <summary>
        ///   Computes the Z test.
        /// </summary>
        ///
        protected void Compute(double statistic, TwoSampleHypothesis alternate)
        {
            this.Statistic             = statistic;
            this.StatisticDistribution = NormalDistribution.Standard;

            this.Hypothesis = alternate;
            this.Tail       = (DistributionTail)alternate;

            this.PValue = StatisticToPValue(Statistic);

            this.OnSizeChanged();
        }
Пример #24
0
        /// <summary>
        ///   Computes the Z test.
        /// </summary>
        ///
        protected void Compute(double value1, double value2,
                               double squareStdError1, double squareStdError2,
                               double hypothesizedDifference, TwoSampleHypothesis alternate)
        {
            this.EstimatedValue1 = value1;
            this.EstimatedValue2 = value2;

            double diff     = value1 - value2;
            double stdError = Math.Sqrt(squareStdError1 + squareStdError2);

            Compute(diff, hypothesizedDifference, stdError, alternate);
        }
        /// <summary>
        ///   Creates a new Two-Table Mean Kappa test.
        /// </summary>
        /// 
        /// <param name="meanKappa1">The average kappa value for the first group of contingency tables.</param>
        /// <param name="meanKappa2">The average kappa value for the second group of contingency tables.</param>
        /// <param name="varKappa1">The kappa's variance in the first group of tables.</param>
        /// <param name="varKappa2">The kappa's variance in the first group of tables.</param>
        /// <param name="kappaSamples1">The number of contingency tables averaged in the first group.</param>
        /// <param name="kappaSamples2">The number of contingency tables averaged in the second group.</param>
        /// <param name="assumeEqualVariances">True to assume equal variances, false otherwise. Default is true.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two Kappa values.</param>
        /// 
        public TwoAverageKappaTest(double meanKappa1, double varKappa1, int kappaSamples1,
            double meanKappa2, double varKappa2, int kappaSamples2,
            double hypothesizedDifference = 0, bool assumeEqualVariances = true,
            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            Variance1 = varKappa1;
            Variance2 = varKappa2;

            base.Compute(
                meanKappa1, varKappa1, kappaSamples1,
                meanKappa2, varKappa2, kappaSamples2,
                hypothesizedDifference, assumeEqualVariances, alternate);
        }
Пример #26
0
        /// <summary>
        ///   Creates a new Two-Table Mean Kappa test.
        /// </summary>
        ///
        /// <param name="meanKappa1">The average kappa value for the first group of contingency tables.</param>
        /// <param name="meanKappa2">The average kappa value for the second group of contingency tables.</param>
        /// <param name="varKappa1">The kappa's variance in the first group of tables.</param>
        /// <param name="varKappa2">The kappa's variance in the first group of tables.</param>
        /// <param name="kappaSamples1">The number of contingency tables averaged in the first group.</param>
        /// <param name="kappaSamples2">The number of contingency tables averaged in the second group.</param>
        /// <param name="assumeEqualVariances">True to assume equal variances, false otherwise. Default is true.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two Kappa values.</param>
        ///
        public TwoAverageKappaTest(double meanKappa1, double varKappa1, int kappaSamples1,
                                   double meanKappa2, double varKappa2, int kappaSamples2,
                                   double hypothesizedDifference = 0, bool assumeEqualVariances = true,
                                   TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            Variance1 = varKappa1;
            Variance2 = varKappa2;

            base.Compute(
                meanKappa1, varKappa1, kappaSamples1,
                meanKappa2, varKappa2, kappaSamples2,
                hypothesizedDifference, assumeEqualVariances, alternate);
        }
        public GeneralHypothesisTest(string firstLabel, DescriptiveResult sample1, string secondLabel,
            DescriptiveResult sample2, double hypothesizedDifference = 0,
            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            int samples1 = sample1.Count;
            int samples2 = sample2.Count;
            HypothesizedDifference = Math.Abs(hypothesizedDifference);

            var s1 = new SampleInfo
                     {
                         Name = firstLabel,
                         Count = sample1.Count,
                         Mean = sample1.Mean,
                         StdDev = sample1.StdDev
                     };

            var s2 = new SampleInfo
                     {
                         Name = secondLabel,
                         Count = sample2.Count,
                         Mean = sample2.Mean,
                         StdDev = sample2.StdDev
                     };

            Result = new ComparisonResult
                     {
                         FirstSample = s1,
                         SecondSample = s2,
                         Hypothesis = alternate,
                         HypothesizedDifference = HypothesizedDifference
                     };

            if (samples1 < 30 || samples2 < 30)
            {
                _tTest = new TwoSampleTTest(sample1, sample2, false, HypothesizedDifference, alternate);
                Result.Confidence = _tTest.Confidence;
                Result.ObservedDifference = _tTest.ObservedDifference;
                Result.Significant = _tTest.Significant;
                Result.Size = _tTest.Size;
                Result.StandardError = _tTest.StandardError;
            }
            else
            {
                _zTest = new TwoSampleZTest(sample1, sample2, HypothesizedDifference, alternate);
                Result.Confidence = _zTest.Confidence;
                Result.ObservedDifference = _zTest.ObservedDifference;
                Result.Significant = _zTest.Significant;
                Result.Size = _zTest.Size;
                Result.StandardError = _zTest.StandardError;
            }
        }
Пример #28
0
 public static TwoSampleHypothesisTestResult TestHypothesis(
     this ITwoSampleNormalDistributionHypothesisTest source,
     BenchmarkResults.BeforeAndAfter resultMeasurement,
     double hypothesizedDifference,
     TwoSampleHypothesis alternateHypothesis,
     double alpha)
 {
     return(source.TestHypothesis(
                resultMeasurement.Baseline.GetResultRuns().Select(run => MeasurementExtensions.GetAverageNanoseconds(run)),
                resultMeasurement.Treatment.GetResultRuns().Select(run => run.GetAverageNanoseconds()),
                hypothesizedDifference,
                alternateHypothesis,
                alpha));
 }
Пример #29
0
        public TwoSampleHypothesisTestResult TestHypothesis(IEnumerable <double> sample1, IEnumerable <double> sample2, double hypothesizedDifference,
                                                            TwoSampleHypothesis alternateHypothesis, double alpha)
        {
            var test = new TwoSampleZTest(
                sample1.ToArray(),
                sample2.ToArray(),
                hypothesizedDifference: hypothesizedDifference,
                alternate: alternateHypothesis);

            test.Size = alpha;
            return(new TwoSampleHypothesisTestResult(
                       test.Significant,
                       test.GetConfidenceInterval(1 - alpha),
                       test.ObservedDifference));
        }
Пример #30
0
        /// <summary>
        ///   Estimates the number of samples necessary to attain the
        ///   required power level for the given effect size.
        /// </summary>
        ///
        /// <param name="delta">The minimum detectable difference.</param>
        /// <param name="standardDeviation">The difference standard deviation.</param>
        /// <param name="power">The desired power level. Default is 0.8.</param>
        /// <param name="alpha">The desired significance level. Default is 0.05.</param>
        /// <param name="hypothesis">The alternative hypothesis (research hypothesis) to be tested.</param>
        /// <param name="proportion">The proportion of observations in the second group
        /// when compared to the first group. A proportion of 2:1 results in twice more
        /// samples in the second group than in the first. Default is 1.</param>
        ///
        /// <returns>The required number of samples.</returns>
        ///
        public static TwoSampleZTestPowerAnalysis GetSampleSize(double delta,
                                                                double standardDeviation       = 1, double proportion = 1.0, double power = 0.8, double alpha = 0.05,
                                                                TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent)
        {
            var analysis = new TwoSampleZTestPowerAnalysis(hypothesis)
            {
                Effect = (delta) / standardDeviation,
                Size   = alpha,
                Power  = power,
            };

            analysis.ComputeSamples(proportion);

            return(analysis);
        }
        public static ComparisonResult RunConcurrentPerformanceComparison(int numIterations, int degreeParallelism,
                                                                          string firstLabel,
                                                                          Action firstOperation, string secondLabel, Action secondOperation, double hypothesizedDifference = 0,
                                                                          TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent)
        {
            var result1    = RunConcurrentPerformanceTest(numIterations, degreeParallelism, firstOperation);
            var result2    = RunConcurrentPerformanceTest(numIterations, degreeParallelism, secondOperation);
            var comparison = new GeneralHypothesisTest(firstLabel, result1.DescriptiveResult, secondLabel,
                                                       result2.DescriptiveResult,
                                                       hypothesizedDifference, hypothesis);

            comparison.Result.FirstSample.Details  = result1;
            comparison.Result.SecondSample.Details = result2;

            return(comparison.Result);
        }
        /// <summary>
        ///   Creates a new Two-Table Kappa test.
        /// </summary>
        /// 
        /// <param name="kappa1">The kappa value for the first contingency table to test.</param>
        /// <param name="kappa2">The kappa value for the second contingency table to test.</param>
        /// <param name="var1">The variance of the kappa value for the first contingency table to test.</param>
        /// <param name="var2">The variance of the kappa value for the second contingency table to test.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two Kappa values.</param>
        /// 
        public TwoMatrixKappaTest(double kappa1, double var1, double kappa2, double var2, double hypothesizedDifference = 0,
            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            this.EstimatedValue1 = kappa1;
            this.EstimatedValue2 = kappa2;

            this.Variance1 = var1;
            this.Variance2 = var2;

            this.OverallVariance = Variance1 + Variance2;

            double diff = Math.Abs(EstimatedValue1 - EstimatedValue2);
            double stdError = Math.Sqrt(OverallVariance);

            Compute(diff, hypothesizedDifference, stdError, alternate);
        }
Пример #33
0
        /// <summary>
        ///   Creates a new Two-Table Kappa test.
        /// </summary>
        ///
        /// <param name="matrix1">The first contingency table to test.</param>
        /// <param name="matrix2">The second contingency table to test.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two Kappa values.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        ///
        public TwoMatrixKappaTest(GeneralConfusionMatrix matrix1, GeneralConfusionMatrix matrix2, double hypothesizedDifference = 0,
                                  TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            this.EstimatedValue1 = matrix1.Kappa;
            this.EstimatedValue2 = matrix2.Kappa;

            this.Variance1 = matrix1.Variance;
            this.Variance2 = matrix2.Variance;

            this.OverallVariance = Variance1 + Variance2;

            double diff     = Math.Abs(EstimatedValue1 - EstimatedValue2);
            double stdError = Math.Sqrt(OverallVariance);

            Compute(diff, hypothesizedDifference, stdError, alternate);
        }
Пример #34
0
        /// <summary>
        ///   Creates a new Two-Table Kappa test.
        /// </summary>
        ///
        /// <param name="kappa1">The kappa value for the first contingency table to test.</param>
        /// <param name="kappa2">The kappa value for the second contingency table to test.</param>
        /// <param name="var1">The variance of the kappa value for the first contingency table to test.</param>
        /// <param name="var2">The variance of the kappa value for the second contingency table to test.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two Kappa values.</param>
        ///
        public TwoMatrixKappaTest(double kappa1, double var1, double kappa2, double var2, double hypothesizedDifference = 0,
                                  TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            this.EstimatedValue1 = kappa1;
            this.EstimatedValue2 = kappa2;

            this.Variance1 = var1;
            this.Variance2 = var2;

            this.OverallVariance = Variance1 + Variance2;

            double diff     = Math.Abs(EstimatedValue1 - EstimatedValue2);
            double stdError = Math.Sqrt(OverallVariance);

            Compute(diff, hypothesizedDifference, stdError, alternate);
        }
Пример #35
0
        /// <summary>
        ///   Estimates the number of samples necessary to attain the
        ///   required power level for the given effect size.
        /// </summary>
        ///
        /// <param name="sampleSize1">The number of observations in the first sample.</param>
        /// <param name="sampleSize2">The number of observations in the second sample.</param>
        /// <param name="power">The desired power level. Default is 0.8.</param>
        /// <param name="alpha">The desired significance level. Default is 0.05.</param>
        /// <param name="hypothesis">The alternative hypothesis (research hypothesis) to be tested.</param>
        ///
        /// <returns>The required number of samples.</returns>
        ///
        public static TwoSampleZTestPowerAnalysis GetEffectSize(int sampleSize1, int sampleSize2,
                                                                double power = 0.8, double alpha = 0.05,
                                                                TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent)
        {
            var analysis = new TwoSampleZTestPowerAnalysis(hypothesis)
            {
                Samples1 = sampleSize1,
                Samples2 = sampleSize2,
                Size     = alpha,
                Power    = power,
            };

            analysis.ComputeEffect();

            return(analysis);
        }
Пример #36
0
        public void WilcoxonSignedRankTestConstructorTest()
        {
            // Example from http://en.wikipedia.org/wiki/Wilcoxon_signed-rank_test

            double[] sample1 = { 125, 115, 130, 140, 140, 115, 140, 125, 140, 135 };
            double[] sample2 = { 110, 122, 125, 120, 140, 124, 123, 137, 135, 145 };

            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent;
            var target = new TwoSampleWilcoxonSignedRankTest(sample1, sample2, alternate);

            // Wikipedia uses an alternate definition for the W statistic. The framework
            // uses the positive W statistic. There is no difference, if the proper
            // respective statistical tables (or distributions) are followed.
            Assert.AreEqual(27, target.Statistic);
            Assert.IsFalse(target.Significant);
        }
        public static ComparisonResult RunConcurrentPerformanceComparison(int numIterations, int degreeParallelism,
            string firstLabel,
            Action firstOperation, string secondLabel, Action secondOperation, double hypothesizedDifference = 0,
            TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent)
        {
            var result1 = RunConcurrentPerformanceTest(numIterations, degreeParallelism, firstOperation);
            var result2 = RunConcurrentPerformanceTest(numIterations, degreeParallelism, secondOperation);
            var comparison = new GeneralHypothesisTest(firstLabel, result1.DescriptiveResult, secondLabel,
                result2.DescriptiveResult,
                hypothesizedDifference, hypothesis);

            comparison.Result.FirstSample.Details = result1;
            comparison.Result.SecondSample.Details = result2;

            return comparison.Result;
        }
        /// <summary>
        ///   Creates a new sign test for two samples.
        /// </summary>
        /// 
        /// <param name="sample1">The first sample of observations.</param>
        /// <param name="sample2">The second sample of observations.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// 
        public TwoSampleSignTest(double[] sample1, double[] sample2, TwoSampleHypothesis alternate)
        {
            if (sample1.Length != sample2.Length)
                throw new DimensionMismatchException("sample2", "Both samples should be of the same size.");

            int positive = 0;
            int negative = 0;

            for (int i = 0; i < sample1.Length; i++)
            {
                double d = sample2[i] - sample1[i];

                if (d > 0) positive++;
                else if (d < 0) negative++;
            }

            Compute(positive, positive + negative, alternate);
        }
Пример #39
0
        /// <summary>
        ///   Computes the Z-test for two sample proportions.
        /// </summary>
        /// 
        protected void Compute(
            int successes1, int trials1,
            int successes2, int trials2,
            TwoSampleHypothesis alternate)
        {
            double p1 = successes1 / (double)trials1;
            double p2 = successes2 / (double)trials2;
            double p = (successes1 + successes2) / (double)(trials1 + trials2);

            EstimatedValue1 = p1;
            EstimatedValue2 = p2;
            ObservedDifference = p1 - p2;
            StandardError = Math.Sqrt(p * (1 - p) * (1.0 / trials1 + 1.0 / trials2));

            double z = ObservedDifference / StandardError;

            Compute(z, alternate);
        }
        public static bool RunConcurrentPerformanceComparison(int numIterations, int degreeParallelism,
            string firstLabel,
            Action firstOperation, string secondLabel, Action secondOperation, double hypothesizedDifference = 0,
            TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent, bool outputDetails = false)
        {
            var comparison =  RunConcurrentPerformanceComparison(numIterations, degreeParallelism, firstLabel, firstOperation,
                secondLabel, secondOperation, hypothesizedDifference, hypothesis);

            if (outputDetails)
            {
                Console.WriteLine(comparison.ToString());
                Console.WriteLine("-----{0}-----", firstLabel);
                Console.WriteLine(comparison.FirstSample.Details.ToString());
                Console.WriteLine("-----{0}-----", secondLabel);
                Console.WriteLine(comparison.SecondSample.Details.ToString());
            }

            return comparison.Significant;
        }
        /// <summary>
        ///   Tests whether the medians of two paired samples are different.
        /// </summary>
        /// 
        /// <param name="sample1">The first sample.</param>
        /// <param name="sample2">The second sample.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// 
        public TwoSampleWilcoxonSignedRankTest(double[] sample1, double[] sample2,
            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            if (sample1.Length != sample2.Length)
                throw new DimensionMismatchException("sample2", "Both samples should be of the same size.");

            int[] signs = new int[sample1.Length];
            double[] diffs = new double[sample1.Length];

            // 1. Compute absolute difference and sign function
            for (int i = 0; i < sample1.Length; i++)
            {
                double d = sample1[i] - sample2[i];
                signs[i] = Math.Sign(d);
                diffs[i] = Math.Abs(d);
            }

            this.Hypothesis = alternate;
            Compute(signs, diffs, (DistributionTail)alternate);
        }
 public GeneralHypothesisTest(DescriptiveResult sample1, DescriptiveResult sample2,
     double hypothesizedDifference = 0,
     TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
     : this("first", sample1, "second", sample2, hypothesizedDifference, alternate)
 {
 }
        /// <summary>
        ///   Estimates the number of samples necessary to attain the
        ///   required power level for the given effect size.
        /// </summary>
        /// 
        /// <param name="delta">The minimum detectable difference.</param>
        /// <param name="variance1">The first sample variance.</param>
        /// <param name="variance2">The second sample variance.</param>
        /// <param name="power">The desired power level. Default is 0.8.</param>
        /// <param name="alpha">The desired significance level. Default is 0.05.</param>
        /// <param name="proportion">The proportion of observations in the second group
        /// when compared to the first group. A proportion of 2:1 results in twice more
        /// samples in the second group than in the first. Default is 1.</param>
        /// <param name="hypothesis">The alternative hypothesis (research hypothesis) to be tested.</param>
        /// 
        /// <returns>The required number of samples.</returns>
        /// 
        public static TwoSampleTTestPowerAnalysis GetSampleSize(double delta,
            double variance1, double variance2, double proportion = 1.0, double power = 0.8,
            double alpha = 0.05, TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent)
        {
            double standardDeviation = Math.Sqrt((variance1 + variance2) / 2.0);

            var analysis = new TwoSampleTTestPowerAnalysis(hypothesis)
            {
                Effect = delta / standardDeviation,
                Size = alpha,
                Power = power,
            };

            analysis.ComputeSamples(proportion);

            return analysis;
        }
Пример #44
0
        /// <summary>
        ///   Creates a new Two-Table Mean Kappa test.
        /// </summary>
        /// 
        /// <param name="matrices1">The first group of contingency tables.</param>
        /// <param name="matrices2">The second  group of contingency tables.</param>
        /// <param name="assumeEqualVariances">True to assume equal variances, false otherwise. Default is true.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two average Kappa values.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// 
        public TwoAverageKappaTest(GeneralConfusionMatrix[] matrices1, GeneralConfusionMatrix[] matrices2,
            double hypothesizedDifference = 0, bool assumeEqualVariances = true,
            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {

            double[] kappas1 = new double[matrices1.Length];
            for (int i = 0; i < matrices1.Length; i++)
                kappas1[i] = matrices1[i].Kappa;

            double[] kappas2 = new double[matrices1.Length];
            for (int i = 0; i < matrices2.Length; i++)
                kappas2[i] = matrices2[i].Kappa;

            double meanKappa1 = kappas1.Mean();
            double meanKappa2 = kappas2.Mean();

            Variance1 = kappas1.Variance(meanKappa1);
            Variance2 = kappas2.Variance(meanKappa2);

            int kappaSamples1 = matrices1.Length;
            int kappaSamples2 = matrices2.Length;

            base.Compute(
               meanKappa1, Variance1, kappaSamples1,
               meanKappa2, Variance2, kappaSamples2,
               hypothesizedDifference, assumeEqualVariances, alternate);
        }
        /// <summary>
        ///   Computes the two sample sign test.
        /// </summary>
        /// 
        protected void Compute(int positive, int total, TwoSampleHypothesis alternate)
        {
            this.Hypothesis = alternate;

            // The underlying test is to check whether the probability
            // value from the samples are higher than or lesser than 0.5,
            // thus the actual Binomial test hypothesis is inverted:

            OneSampleHypothesis binomialHypothesis;

            switch (alternate)
            {
                case TwoSampleHypothesis.ValuesAreDifferent:
                    binomialHypothesis = OneSampleHypothesis.ValueIsDifferentFromHypothesis; break;
                case TwoSampleHypothesis.FirstValueIsGreaterThanSecond:
                    binomialHypothesis = OneSampleHypothesis.ValueIsSmallerThanHypothesis; break;
                case TwoSampleHypothesis.FirstValueIsSmallerThanSecond:
                    binomialHypothesis = OneSampleHypothesis.ValueIsGreaterThanHypothesis; break;
                default: throw new InvalidOperationException();
            }

            base.Compute(positive, total, 0.5, binomialHypothesis);
        }
 /// <summary>
 ///   Creates a new sign test for two samples.
 /// </summary>
 /// 
 /// <param name="positiveSamples">The number of positive samples (successes).</param>
 /// <param name="totalSamples">The total number of samples (trials).</param>
 /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
 /// 
 public TwoSampleSignTest(int positiveSamples, int totalSamples, TwoSampleHypothesis alternate)
 {
     Compute(positiveSamples, totalSamples, alternate);
 }
        /// <summary>
        ///   Estimates the number of samples necessary to attain the
        ///   required power level for the given effect size.
        /// </summary>
        /// 
        /// <param name="delta">The minimum detectable difference.</param>
        /// <param name="standardDeviation">The difference standard deviation.</param>
        /// <param name="power">The desired power level. Default is 0.8.</param>
        /// <param name="alpha">The desired significance level. Default is 0.05.</param>
        /// <param name="hypothesis">The alternative hypothesis (research hypothesis) to be tested.</param>
        /// <param name="proportion">The proportion of observations in the second group
        /// when compared to the first group. A proportion of 2:1 results in twice more
        /// samples in the second group than in the first. Default is 1.</param>
        /// 
        /// <returns>The required number of samples.</returns>
        /// 
        public static TwoSampleZTestPowerAnalysis GetSampleSize(double delta,
            double standardDeviation = 1, double proportion = 1.0, double power = 0.8, double alpha = 0.05,
            TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent)
        {
            var analysis = new TwoSampleZTestPowerAnalysis(hypothesis)
            {
                Effect = (delta) / standardDeviation,
                Size = alpha,
                Power = power,
            };

            analysis.ComputeSamples(proportion);

            return analysis;
        }
        /// <summary>
        ///   Estimates the number of samples necessary to attain the
        ///   required power level for the given effect size.
        /// </summary>
        /// 
        /// <param name="sampleSize1">The number of observations in the first sample.</param>
        /// <param name="sampleSize2">The number of observations in the second sample.</param>
        /// <param name="power">The desired power level. Default is 0.8.</param>
        /// <param name="alpha">The desired significance level. Default is 0.05.</param>
        /// <param name="hypothesis">The alternative hypothesis (research hypothesis) to be tested.</param>
        /// 
        /// <returns>The required number of samples.</returns>
        /// 
        public static TwoSampleZTestPowerAnalysis GetEffectSize(int sampleSize1, int sampleSize2,
            double power = 0.8, double alpha = 0.05,
            TwoSampleHypothesis hypothesis = TwoSampleHypothesis.ValuesAreDifferent)
        {
            var analysis = new TwoSampleZTestPowerAnalysis(hypothesis)
            {
                Samples1 = sampleSize1,
                Samples2 = sampleSize2,
                Size = alpha,
                Power = power,
            };

            analysis.ComputeEffect();

            return analysis;
        }
 /// <summary>
 ///   Creates a new <see cref="ZTestPowerAnalysis"/>.
 /// </summary>
 /// 
 /// <param name="hypothesis">The hypothesis tested.</param>
 /// 
 public TwoSampleZTestPowerAnalysis(TwoSampleHypothesis hypothesis)
     : base((DistributionTail)hypothesis)
 {
 }
Пример #50
0
        /// <summary>
        ///   Creates a new Two-Table Kappa test.
        /// </summary>
        /// 
        /// <param name="matrix1">The first contingency table to test.</param>
        /// <param name="matrix2">The second contingency table to test.</param>
        /// <param name="hypothesizedDifference">The hypothesized difference between the two Kappa values.</param>
        /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
        /// 
        public TwoMatrixKappaTest(GeneralConfusionMatrix matrix1, GeneralConfusionMatrix matrix2, double hypothesizedDifference = 0,
            TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
        {
            this.EstimatedValue1 = matrix1.Kappa;
            this.EstimatedValue2 = matrix2.Kappa;

            this.Variance1 = matrix1.Variance;
            this.Variance2 = matrix2.Variance;

            this.OverallVariance = Variance1 + Variance2;

            double diff = Math.Abs(EstimatedValue1 - EstimatedValue2);
            double stdError = Math.Sqrt(OverallVariance);

            Compute(diff, hypothesizedDifference, stdError, alternate);
        }
Пример #51
0
 /// <summary>
 ///   Creates a new Z-Test for two sample proportions.
 /// </summary>
 /// 
 /// <param name="successes1">The number of successes in the first sample.</param>
 /// <param name="trials1">The total number of trials (observations) in the first sample.</param>
 /// <param name="successes2">The number of successes in the second sample.</param>
 /// <param name="trials2">The total number of trials (observations) in the second sample.</param>
 /// <param name="alternate">The alternative hypothesis (research hypothesis) to test.</param>
 /// 
 public TwoProportionZTest(int successes1, int trials1, int successes2, int trials2,
     TwoSampleHypothesis alternate = TwoSampleHypothesis.ValuesAreDifferent)
 {
     Compute(successes1, trials1, successes2, trials2, alternate);
 }