private void TestAdiComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e) { _test = FTest.Select(TestAdiComboBox.SelectedValue.ToString()); Sure.Text = _test.Sure.ToString(); SoruSayisi.Text = _test.SoruSayisi.ToString(); CevapSayisi.Text = _test.CevapSayisi.ToString(); }
public KullaniciSayfasi(string testAdi) { InitializeComponent(); _colors = Global.Colors(); _icons = Global.Icons(); _testAdi = testAdi; _test = FTest.Select(_testAdi); // Boş Yapma }
protected override void EndProcessing() { var hypo = TestingHelper.GetTwoSampleHypothesis(Alternate); var test = new FTest(Variance1, Variance2, DegreesOfFreedom1, DegreesOfFreedom2, hypo) { Size = Size }; WriteObject(test); }
void TestAdiDoldur() { TestCombobox.Items.Clear(); testler = new List <Test>(); testler = FTest.SelectAll(Global.ServerKullanici.KullaniciId); if (testler == null) { return; } foreach (var test in testler) { TestCombobox.Items.Add(test.TestAdi); } }
static void Main(string[] args) { city a = new city(); FTest ReadGeoF = new FTest(a.readGeo); mega b = new mega(); STest ReadGeoS = new STest(b.readGeo); STest ReadNameS = new STest(b.readName); region c = new region(); TTest ReadGeoT = new TTest(c.readGeo); TTest ReadNameT = new TTest(c.readName); TTest Sum; Sum = ReadGeoT + ReadNameT; }
public void FTestConstructorTest2() { // The following example has been based on the page "F-Test for Equality // of Two Variances", from NIST/SEMATECH e-Handbook of Statistical Methods: // // http://www.itl.nist.gov/div898/handbook/eda/section3/eda359.htm // // Consider a data set containing 480 ceramic strength // measurements for two batches of material. The summary // statistics for each batch are shown below: // BATCH 1: int numberOfObservations1 = 240; // double mean1 = 688.9987; double stdDev1 = 65.54909; double var1 = stdDev1 * stdDev1; // BATCH 2: int numberOfObservations2 = 240; // double mean2 = 611.1559; double stdDev2 = 61.85425; double var2 = stdDev2 * stdDev2; // Here, we will be testing the null hypothesis that // the variances for the two batches are equal. int degreesOfFreedom1 = numberOfObservations1 - 1; int degreesOfFreedom2 = numberOfObservations2 - 1; // Now we can create a F-Test to test the difference between variances var ftest = new FTest(var1, var2, degreesOfFreedom1, degreesOfFreedom2); double statistic = ftest.Statistic; // 1.123037 double pvalue = ftest.PValue; // 0.185191 bool significant = ftest.Significant; // false // The F test indicates that there is not enough evidence // to reject the null hypothesis that the two batch variances // are equal at the 0.05 significance level. Assert.AreEqual(1.1230374607443194, statistic); Assert.AreEqual(0.18519157993853722, pvalue); Assert.IsFalse(significant); }
/// <summary> /// Calculates the N Value for each protein based on its intensity values in two conditions /// </summary> /// //need explanation on what an N value is public void GetNValueUsingTTest(List <double> proteinFirstConditionIntensityValues, List <double> proteinSecondConditionIntensityValues, List <double> actualNValues, List <double> actualPValues, List <double> actualLogFoldChange, double sOValue) { //why are these being cloned? double[] firstConditionIntensityValues = new double[proteinFirstConditionIntensityValues.Count]; double[] secondConditionIntensityValues = new double[proteinSecondConditionIntensityValues.Count]; for (int i = 0; i < proteinFirstConditionIntensityValues.Count; i++) { firstConditionIntensityValues[i] = proteinFirstConditionIntensityValues[i]; } for (int i = 0; i < proteinSecondConditionIntensityValues.Count; i++) { secondConditionIntensityValues[i] = proteinSecondConditionIntensityValues[i]; } //sometimes less is more with variable names. For example, "mean1" vs "firstConditionIntensityMean" improves readability without diminishing clarity double firstConditionIntensityMean = CalculateProteinMeanIntensityValue(firstConditionIntensityValues); double secondConditionIntensityMean = CalculateProteinMeanIntensityValue(secondConditionIntensityValues); double firstConditionIntensityStandardDev = CalculateProteinIntensityValuesStandardDeviation(firstConditionIntensityValues, firstConditionIntensityMean); double secondConditionIntensityStandardDev = CalculateProteinIntensityValuesStandardDeviation(secondConditionIntensityValues, secondConditionIntensityMean); double firstConditionIntensityVariance = firstConditionIntensityStandardDev * firstConditionIntensityStandardDev; double secondConditionIntensityVariance = secondConditionIntensityStandardDev * secondConditionIntensityStandardDev; //don't need to save "ftest" if you're never going to use it again //write a note here what the purpose of the f-test is. It's not as well known as the t-test var ftest = new FTest(firstConditionIntensityVariance, secondConditionIntensityVariance, proteinFirstConditionIntensityValues.Count - 1, proteinSecondConditionIntensityValues.Count - 1); bool significant = ftest.Significant; // gets whether null hypothesis can be rejected // Create two tailed t test to get p values TwoSampleTTest ttest = new TwoSampleTTest(firstConditionIntensityValues, secondConditionIntensityValues, !significant); double pValue = ttest.PValue; double logpValue = -Math.Log10(pValue); double logfoldChange = secondConditionIntensityMean - firstConditionIntensityMean; //need a note on where this came from double nValue = (logpValue * (logfoldChange * logfoldChange - sOValue * sOValue)) / ((logfoldChange) * (logfoldChange)); //these are interesting names that imply the existence of fake nvalues, foldchanges, and pvalues. //how about "allNValues"? actualNValues.Add(nValue); actualLogFoldChange.Add(logfoldChange); actualPValues.Add(pValue); }
/// <summary> /// Calculates the N Value for each protein based on its intensity values in two conditions. /// the permutationTesting boolean is used to determine if we are caluclating permuted or observed N Values. /// /// The N value is a metric which combines the pValue and the magnitude change (through the LogFoldChange) of /// the protein amongst the two conditions in order to enable significance classifcation of the protein based /// on the same principle of Volcano Plots (Volcano plots allow to identify signifcantly different proteins in large data /// sets comprising of replicate data by plotting the signifance statistic on the y axis, which is the pValue here, /// and the magnitude chanbge on the x axis, which is the logFoldChange here) /// </summary> public List <double> GetNValueUsingTTest(List <double> proteinFirstConditionIntensityValues, List <double> proteinSecondConditionIntensityValues, double sOValue, bool permutationTesting) { double mean1 = proteinFirstConditionIntensityValues.Average(); double mean2 = proteinSecondConditionIntensityValues.Average(); double stdDev1 = CalculateProteinIntensityValuesStandardDeviation(proteinFirstConditionIntensityValues, mean1); double stdDev2 = CalculateProteinIntensityValuesStandardDeviation(proteinSecondConditionIntensityValues, mean2); double variance1 = stdDev1 * stdDev1; double variance2 = stdDev2 * stdDev2; // the f-test is used to determine whether the variance of the two intensityvalue popluations are equal // the significant variable gets whether the null hypothesis can be rejected bool significant = new FTest(variance1, variance2, proteinFirstConditionIntensityValues.Count - 1, proteinSecondConditionIntensityValues.Count - 1).Significant; // Create two tailed t test to get p values TwoSampleTTest ttest = new TwoSampleTTest(mean1, variance1, proteinFirstConditionIntensityValues.Count, mean2, variance2, proteinSecondConditionIntensityValues.Count, !significant); double pValue = ttest.PValue; double logpValue = -Math.Log10(pValue); double logfoldChange = mean2 - mean1; // compute N-Value for protein double nValue = (logpValue * (logfoldChange * logfoldChange - sOValue * sOValue)) / ((logfoldChange) * (logfoldChange)); if (!permutationTesting) { List <double> proteinStatistics = new List <double>(); proteinStatistics.Add(nValue); proteinStatistics.Add(pValue); proteinStatistics.Add(logfoldChange); return(proteinStatistics); //nValues.Add(nValue); ///logFoldChange.Add(logfoldChange); //pValues.Add(pValue); } else { List <double> proteinStatistics = new List <double>(); proteinStatistics.Add(nValue); return(proteinStatistics); //nValues.Add(nValue); } }
private void UserControl_Loaded(object sender, RoutedEventArgs e) { testler = new List <Test>(); if (Global.ServerKullanici == null) { return; } testler = FTest.SelectAll(Global.ServerKullanici.KullaniciId); if (testler == null) { return; } foreach (var test in testler) { TestAdiComboBox.Items.Add(test.TestAdi); } }
public void FTestConstructorTest() { double var1 = 1.05766555271071; double var2 = 1.16570834301777; int d1 = 49; int d2 = 49; FTest oneGreater = new FTest(var1, var2, d1, d2, TwoSampleHypothesis.FirstValueIsGreaterThanSecond); FTest oneSmaller = new FTest(var1, var2, d1, d2, TwoSampleHypothesis.FirstValueIsSmallerThanSecond); FTest twoTail = new FTest(var1, var2, d1, d2, TwoSampleHypothesis.ValuesAreDifferent); Assert.AreEqual(0.632, oneGreater.PValue, 1e-3); Assert.AreEqual(0.367, oneSmaller.PValue, 1e-3); Assert.AreEqual(0.734, twoTail.PValue, 1e-3); Assert.IsFalse(Double.IsNaN(oneGreater.PValue)); Assert.IsFalse(Double.IsNaN(oneSmaller.PValue)); Assert.IsFalse(Double.IsNaN(twoTail.PValue)); }
public static void FirstDoesNotHaveHigherVariance(AggregateMetrics first, AggregateMetrics second) { double[] firstSamples = first.Runs.Select(run => run.ElapsedNanos).ToArray(); double[] secondSamples = second.Runs.Select(run => run.ElapsedNanos).ToArray(); // Fisher's F-test (also known as Snedecor) var firstVariance = Measures.Variance(firstSamples); var secondVariance = Measures.Variance(secondSamples); var fishersFTest = new FTest( firstVariance, secondVariance, firstSamples.Length - 1, secondSamples.Length - 1, TwoSampleHypothesis.FirstValueIsGreaterThanSecond); Trace.WriteLine( "FTest Var(s1) > Var(s2): " + fishersFTest.PValue + " - Significant: " + fishersFTest.Significant + " - Hyp: " + fishersFTest.Hypothesis); PerfAssertContext.AssertIsFalse(fishersFTest.Significant); }
private void compute(double[][] x, double[] y) { int n = x.Length; int p = NumberOfInputs; SSt = 0; SSe = 0; outputMean = 0.0; NumberOfSamples = x.Length; // Compute the regression OrdinaryLeastSquares.Token = Token; regression = OrdinaryLeastSquares.Learn(x, y); informationMatrix = OrdinaryLeastSquares.GetInformationMatrix(); // Calculate mean of the expected outputs outputMean = y.Mean(); // Calculate actual outputs (results) #pragma warning disable 612, 618 results = regression.Transform(x); // Calculate SSe and SSt for (int i = 0; i < x.Length; i++) { double d; d = y[i] - results[i]; SSe += d * d; d = y[i] - outputMean; SSt += d * d; } // Calculate SSr SSr = SSt - SSe; // Calculate R-Squared rSquared = (SSt != 0) ? 1.0 - (SSe / SSt) : 1.0; // Calculated Adjusted R-Squared if (rSquared == 1) { rAdjusted = 1; } else { if (n - p == 1) { rAdjusted = double.NaN; } else { rAdjusted = 1.0 - (1.0 - rSquared) * ((n - 1.0) / (n - p - 1.0)); } } // Calculate Degrees of Freedom DFr = p; DFe = n - (p + 1); DFt = DFr + DFe; // Calculate Sum of Squares Mean MSe = SSe / DFe; MSr = SSr / DFr; MSt = SSt / DFt; // Calculate the F statistic ftest = new FTest(MSr / MSe, DFr, DFe); stdError = Math.Sqrt(MSe); // Create the ANOVA table List <AnovaVariationSource> table = new List <AnovaVariationSource>(); table.Add(new AnovaVariationSource(this, "Regression", SSr, DFr, MSr, ftest)); table.Add(new AnovaVariationSource(this, "Error", SSe, DFe, MSe, null)); table.Add(new AnovaVariationSource(this, "Total", SSt, DFt, MSt, null)); this.anovaTable = new AnovaSourceCollection(table); // Compute coefficient standard errors; standardErrors = new double[NumberOfInputs + 1]; for (int i = 0; i < informationMatrix.Length; i++) { standardErrors[i] = Math.Sqrt(MSe * informationMatrix[i][i]); } // Compute coefficient tests for (int i = 0; i < CoefficientValues.Length; i++) { double tStatistic = CoefficientValues[i] / standardErrors[i]; ttests[i] = new TTest(estimatedValue: CoefficientValues[i], standardError: standardErrors[i], degreesOfFreedom: DFe); ftests[i] = new FTest(tStatistic * tStatistic, 1, DFe); confidences[i] = ttests[i].GetConfidenceInterval(confidencePercent); } // Compute model performance tests ttest = new TTest(results, outputMean); ztest = new ZTest(results, outputMean); chiSquareTest = new ChiSquareTest(y, results, n - p - 1); #pragma warning restore 612, 618 }
/// <summary> /// Generates fake N Value's for each protein based on its intensity values in two conditions using Permutation Testing /// </summary> /// //alright, you win, I guess there are fake nvalues. Maybe a better nomenclature would be observedNValues vs permutedNValues? /// There's a lot of code duplication between this method and GetNValueUsingTTest. Try creating permutations and then calling GetNValueUsingTTest for each one. public void GetNValueUsingPermutationtests(List <double> proteinFirstConditionIntensityValues, List <double> proteinSecondConditionIntensityValues, List <double> permutedNValues, double sOValue) { //why are these being cloned? double[] firstConditionIntensityValues = new double[proteinFirstConditionIntensityValues.Count]; double[] secondConditionIntensityValues = new double[proteinSecondConditionIntensityValues.Count]; for (int i = 0; i < proteinFirstConditionIntensityValues.Count; i++) { firstConditionIntensityValues[i] = proteinFirstConditionIntensityValues[i]; } for (int i = 0; i < proteinSecondConditionIntensityValues.Count; i++) { secondConditionIntensityValues[i] = proteinSecondConditionIntensityValues[i]; } int[] indicesOfFirstConditionIntensityValues = new int[firstConditionIntensityValues.Length]; int[] indicesOfSecondConditionIntensityValues = new int[secondConditionIntensityValues.Length]; for (int i = 0; i < proteinFirstConditionIntensityValues.Count; i++) { indicesOfFirstConditionIntensityValues[i] = i; } for (int i = 0; i < proteinSecondConditionIntensityValues.Count; i++) { indicesOfSecondConditionIntensityValues[i] = i; } List <List <int> > allTwoIndiciesCombinationsFromFirstCondition = GenerateAllCombinationsOfTwoIndices(indicesOfFirstConditionIntensityValues); List <List <int> > allTwoIndiciesCombinationsFromSecondCondition = GenerateAllCombinationsOfTwoIndices(indicesOfSecondConditionIntensityValues); int count = 0; foreach (var twoIndiciesCombinationEntryFromFirstCondition in allTwoIndiciesCombinationsFromFirstCondition) { foreach (var twoIndiciesCombinationEntryFromSecondCondition in allTwoIndiciesCombinationsFromSecondCondition) { // these the new arrays which will be made after swapping intensity values between the two conditions double[] swappedFirstConditionIntensityValues = new double[firstConditionIntensityValues.Length]; double[] swappedSecondConditionIntensityValues = new double[secondConditionIntensityValues.Length]; int swappedFirstConditionArrayTracker = 0; int swappedSecondConditionArrayTracker = 0; int[] indiciesToSwapFromFirstCondition = new int[2]; int[] indiciesToSwapFromSecondCondition = new int[2]; int removeIndiciesFirstConditionTracker = 0; int removeIndiciesSecondConditionTracker = 0; // store the indices, corresponding to intensity values, to be swapped from first condition foreach (var index in twoIndiciesCombinationEntryFromFirstCondition) { indiciesToSwapFromFirstCondition[removeIndiciesFirstConditionTracker] = index; removeIndiciesFirstConditionTracker++; } // store the indices, corresponding to intensity values, to be swapped from second condition foreach (var index in twoIndiciesCombinationEntryFromSecondCondition) { indiciesToSwapFromSecondCondition[removeIndiciesSecondConditionTracker] = index; removeIndiciesSecondConditionTracker++; } // add the intensity values to be swapped from first condition the second condition for (int j = 0; j < indiciesToSwapFromFirstCondition.Count(); j++) { swappedSecondConditionIntensityValues[swappedSecondConditionArrayTracker] = firstConditionIntensityValues[indiciesToSwapFromFirstCondition[j]]; swappedSecondConditionArrayTracker++; } // add the intensity values to be swapped from second condition the first condition for (int j = 0; j < indiciesToSwapFromSecondCondition.Count(); j++) { swappedFirstConditionIntensityValues[swappedFirstConditionArrayTracker] = secondConditionIntensityValues[indiciesToSwapFromSecondCondition[j]]; swappedFirstConditionArrayTracker++; } // now we add the remaining intensity values from the first condition to the swappedFirstCondition Array for (int j = 0; j < firstConditionIntensityValues.Count(); j++) { if (indiciesToSwapFromFirstCondition.Contains(j)) { continue; } swappedFirstConditionIntensityValues[swappedFirstConditionArrayTracker] = firstConditionIntensityValues[j]; swappedFirstConditionArrayTracker++; } // now we add the remaining intensity values from the second condition to the swappedSecondCondition Array for (int j = 0; j < secondConditionIntensityValues.Count(); j++) { if (indiciesToSwapFromSecondCondition.Contains(j)) { continue; } swappedSecondConditionIntensityValues[swappedSecondConditionArrayTracker] = secondConditionIntensityValues[j]; swappedSecondConditionArrayTracker++; } // at this stage we have the newly made swapped arrays with mixture of groups. // need to proceed with T tests for these groups to generate fake p values. double firstConditionIntensityMean = CalculateProteinMeanIntensityValue(swappedFirstConditionIntensityValues); double secondConditionIntensityMean = CalculateProteinMeanIntensityValue(swappedSecondConditionIntensityValues); double firstConditionIntensityStandardDev = CalculateProteinIntensityValuesStandardDeviation(swappedFirstConditionIntensityValues, firstConditionIntensityMean); double secondConditionIntensityStandardDev = CalculateProteinIntensityValuesStandardDeviation(swappedSecondConditionIntensityValues, secondConditionIntensityMean); double firstConditionIntensityVariance = firstConditionIntensityStandardDev * firstConditionIntensityStandardDev; double secondConditionIntensityVariance = secondConditionIntensityStandardDev * secondConditionIntensityStandardDev; var ftest = new FTest(firstConditionIntensityVariance, secondConditionIntensityVariance, swappedFirstConditionIntensityValues.Length - 1, swappedSecondConditionIntensityValues.Length - 1); bool significant = ftest.Significant; // gets whether null hypothesis can be rejected // Create two tailed t test to get p values TwoSampleTTest ttest = new TwoSampleTTest(swappedFirstConditionIntensityValues, swappedSecondConditionIntensityValues, !significant); double pValue = ttest.PValue; double logpValue = -Math.Log10(pValue); double logfoldChange = secondConditionIntensityMean - firstConditionIntensityMean; permutedNValues.Add((logpValue * (logfoldChange * logfoldChange - sOValue * sOValue)) / ((logfoldChange) * (logfoldChange))); } count++; if (count == 2) { break; } } }
public void ComputeTest2() { // Consider the following data. An experimenter would // like to infer a relationship between two variables // A and B and a corresponding outcome variable R. double[][] example = { // A B R new double[] { 6.41, 10.11, 26.1 }, new double[] { 6.61, 22.61, 33.8 }, new double[] { 8.45, 11.11, 52.7 }, new double[] { 1.22, 18.11, 16.2 }, new double[] { 7.42, 12.81, 87.3 }, new double[] { 4.42, 10.21, 12.5 }, new double[] { 8.61, 11.94, 77.5 }, new double[] { 1.73, 13.13, 12.1 }, new double[] { 7.47, 17.11, 86.5 }, new double[] { 6.11, 15.13, 62.8 }, new double[] { 1.42, 16.11, 17.5 }, }; // For this, we first extract the input and output // pairs. The first two columns have values for the // input variables, and the last for the output: double[][] inputs = example.GetColumns(0, 1); double[] output = example.GetColumn(2); // Next, we can create a new multiple linear regression for the variables var regression = new MultipleLinearRegressionAnalysis(inputs, output, intercept: true); regression.Compute(); // compute the analysis // Now we can show a summary of analysis // Accord.Controls.DataGridBox.Show(regression.Coefficients); // We can also show a summary ANOVA // Accord.Controls.DataGridBox.Show(regression.Table); // And also extract other useful information, such // as the linear coefficients' values and std errors: double[] coef = regression.CoefficientValues; double[] stde = regression.StandardErrors; // Coefficients of performance, such as r² double rsquared = regression.RSquared; // Hypothesis tests for the whole model ZTest ztest = regression.ZTest; FTest ftest = regression.FTest; // and for individual coefficients TTest ttest0 = regression.Coefficients[0].TTest; TTest ttest1 = regression.Coefficients[1].TTest; // and also extract confidence intervals DoubleRange ci = regression.Coefficients[0].Confidence; Assert.AreEqual(3, coef.Length); Assert.AreEqual(8.7405051051757816, coef[0]); Assert.AreEqual(1.1198079243314365, coef[1], 1e-10); Assert.AreEqual(-19.604474518407862, coef[2], 1e-10); Assert.IsFalse(coef.HasNaN()); Assert.AreEqual(2.375916659234715, stde[0], 1e-10); Assert.AreEqual(1.7268508921418664, stde[1], 1e-10); Assert.AreEqual(30.989640986710953, stde[2], 1e-10); Assert.IsFalse(coef.HasNaN()); Assert.AreEqual(0.62879941171298936, rsquared); Assert.AreEqual(0.99999999999999822, ztest.PValue); Assert.AreEqual(0.018986050133298293, ftest.PValue, 1e-10); Assert.AreEqual(0.0062299844256985537, ttest0.PValue); Assert.AreEqual(0.53484850318449118, ttest1.PValue, 1e-14); Assert.IsFalse(Double.IsNaN(ttest1.PValue)); Assert.AreEqual(3.2616314640800566, ci.Min); Assert.AreEqual(14.219378746271506, ci.Max); }
public void learn_Test() { #region doc_learn_part1 // Consider the following data. An experimenter would // like to infer a relationship between two variables // A and B and a corresponding outcome variable R. double[][] example = { // A B R new double[] { 6.41, 10.11, 26.1 }, new double[] { 6.61, 22.61, 33.8 }, new double[] { 8.45, 11.11, 52.7 }, new double[] { 1.22, 18.11, 16.2 }, new double[] { 7.42, 12.81, 87.3 }, new double[] { 4.42, 10.21, 12.5 }, new double[] { 8.61, 11.94, 77.5 }, new double[] { 1.73, 13.13, 12.1 }, new double[] { 7.47, 17.11, 86.5 }, new double[] { 6.11, 15.13, 62.8 }, new double[] { 1.42, 16.11, 17.5 }, }; // For this, we first extract the input and output // pairs. The first two columns have values for the // input variables, and the last for the output: double[][] inputs = example.GetColumns(new[] { 0, 1 }); double[] output = example.GetColumn(2); // We can create a new multiple linear analysis for the variables var mlra = new MultipleLinearRegressionAnalysis(intercept: true); // Compute the analysis and obtain the estimated regression MultipleLinearRegression regression = mlra.Learn(inputs, output); #endregion // We can also show a summary ANOVA // Accord.Controls.DataGridBox.Show(regression.Table); #region doc_learn_part2 // And also extract other useful information, such // as the linear coefficients' values and std errors: double[] coef = mlra.CoefficientValues; double[] stde = mlra.StandardErrors; // Coefficients of performance, such as r² double rsquared = mlra.RSquared; // 0.62879 // Hypothesis tests for the whole model ZTest ztest = mlra.ZTest; // 0.99999 FTest ftest = mlra.FTest; // 0.01898 // and for individual coefficients TTest ttest0 = mlra.Coefficients[0].TTest; // 0.00622 TTest ttest1 = mlra.Coefficients[1].TTest; // 0.53484 // and also extract confidence intervals DoubleRange ci = mlra.Coefficients[0].Confidence; // [3.2616, 14.2193] // We can use the analysis to predict an output for a sample double y = mlra.Regression.Transform(new double[] { 10, 15 }); // We can also obtain confidence intervals for the prediction: DoubleRange pci = mlra.GetConfidenceInterval(new double[] { 10, 15 }); // and also prediction intervals for the same prediction: DoubleRange ppi = mlra.GetPredictionInterval(new double[] { 10, 15 }); #endregion Assert.AreEqual(3, coef.Length); Assert.AreEqual(8.7405051051757816, coef[0]); Assert.AreEqual(1.1198079243314365, coef[1], 1e-10); Assert.AreEqual(-19.604474518407862, coef[2], 1e-10); Assert.IsFalse(coef.HasNaN()); Assert.AreEqual(2.375916659234715, stde[0], 1e-10); Assert.AreEqual(1.7268508921418664, stde[1], 1e-10); Assert.AreEqual(30.989640986710953, stde[2], 1e-10); Assert.IsFalse(coef.HasNaN()); Assert.AreEqual(0.62879941171298936, rsquared, 1e-10); Assert.AreEqual(0.99999999999999822, ztest.PValue, 1e-10); Assert.AreEqual(0.018986050133298293, ftest.PValue, 1e-10); Assert.AreEqual(0.0062299844256985537, ttest0.PValue, 1e-10); Assert.AreEqual(0.53484850318449118, ttest1.PValue, 1e-14); Assert.IsFalse(Double.IsNaN(ttest1.PValue)); Assert.AreEqual(3.2616314640800566, ci.Min, 1e-10); Assert.AreEqual(14.219378746271506, ci.Max, 1e-10); double[][] im = mlra.InformationMatrix; double mse = regression.GetStandardError(inputs, output); DoubleRange epci = regression.GetConfidenceInterval(new double[] { 10, 15 }, mse, inputs.Length, im); Assert.AreEqual(epci.Min, pci.Min, 1e-10); Assert.AreEqual(epci.Max, pci.Max, 1e-10); Assert.AreEqual(55.27840511658215, pci.Min, 1e-10); Assert.AreEqual(113.91698568006086, pci.Max, 1e-10); Assert.AreEqual(28.783074454641557, ppi.Min, 1e-10); Assert.AreEqual(140.41231634200145, ppi.Max, 1e-10); }
/// <summary> /// Crea amb una descripció, un grup i una funció de prova. /// Es considera que el test ha funcionat si la funció torna true. /// Es considera que el test ha fallat si torna false o /// </summary> /// <param name="descripcio">La descripció del test</param> /// <param name="grup">El grup a què pertanyerà aquest test</param> /// <param name="test">El cos de la funció de prova</param> public Test(string descripcio, GrupTest grup, FTest test) : base(descripcio, grup) { resultat = new RTest(); try { test(resultat); } catch (Exception ex) { resultat.Error("No s'ha completat ({0}) [{1}]", ex.Message, ex.StackTrace); } }
private void ToolStripMenuItemTestClick(object sender, EventArgs e) { var ftest = new FTest(); ftest.ShowDialog(); }
private static void Main() //****************************************************************************80 // // Purpose: // // test_values_test() tests test_values(). // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 04 January 2019 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("test_values_test():"); Console.WriteLine(" Test test_values()."); AbramsTest.abram0_values_test(); AbramsTest.abram1_values_test(); AbramsTest.abram2_values_test(); AGMTest.agm_values_test(); AiryTest.airy_ai_values_test(); AiryTest.airy_ai_int_values_test(); AiryTest.airy_ai_prime_values_test(); AiryTest.airy_bi_values_test(); AiryTest.airy_bi_int_values_test(); AiryTest.airy_bi_prime_values_test(); AiryTest.airy_cai_values_test(); AiryTest.airy_cbi_values_test(); AiryTest.airy_gi_values_test(); AiryTest.airy_hi_values_test(); ArcTest.arccos_values_test(); ArcTest.arccosh_values_test(); ArcTest.arcsin_values_test(); ArcTest.arcsinh_values_test(); ArcTest.arctan_values_test(); ArcTest.arctan_int_values_test(); ArcTest.arctanh_values_test(); BeiBellTest.bei0_values_test(); BeiBellTest.bei1_values_test(); BeiBellTest.bell_values_test(); BerTest.ber0_values_test(); BerTest.ber1_values_test(); BernoulliTest.bernoulli_number_values_test(); BernoulliTest.bernoulli_poly_values_test(); BernsteinTest.bernstein_poly_01_values_test(); BesselTest.bessel_i0_values_test(); BesselTest.bessel_i0_int_values_test(); BesselTest.bessel_i0_spherical_values_test(); BesselTest.bessel_i1_values_test(); BesselTest.bessel_i1_spherical_values_test(); BesselTest.bessel_in_values_test(); BesselTest.bessel_ix_values_test(); BesselTest.bessel_j_spherical_values_test(); BesselTest.bessel_j0_values_test(); BesselTest.bessel_j0_int_values_test(); BesselTest.bessel_j0_spherical_values_test(); BesselTest.bessel_j0_zero_values_test(); BesselTest.bessel_j1_values_test(); BesselTest.bessel_j1_spherical_values_test(); BesselTest.bessel_jn_values_test(); BesselTest.bessel_jx_values_test(); BesselTest.bessel_k0_values_test(); BesselTest.bessel_k0_int_values_test(); BesselTest.bessel_k1_values_test(); BesselTest.bessel_kn_values_test(); BesselTest.bessel_kx_values_test(); BesselTest.bessel_y0_values_test(); BesselTest.bessel_y0_int_values_test(); BesselTest.bessel_y0_spherical_values_test(); BesselTest.bessel_y1_values_test(); BesselTest.bessel_y1_spherical_values_test(); BesselTest.bessel_yn_values_test(); BesselTest.bessel_yx_values_test(); BetaTest.beta_values_test(); BetaTest.beta_cdf_values_test(); BetaTest.beta_inc_values_test(); BetaTest.beta_log_values_test(); BetaTest.beta_noncentral_cdf_values_test(); BetaTest.beta_pdf_values_test(); BinomialTest.binomial_values_test(); BinomialTest.binomial_cdf_values_test(); BinomialTest.binomial_pdf_values_test(); BivariateTest.bivariate_normal_cdf_values_test(); ComplexTest.c8_log_values_test(); CatalanTest.catalan_values_test(); CauchyTest.cauchy_cdf_values_test(); CubeRootTest.cbrt_values_test(); ChebyshevTest.cheby_t_poly_values_test(); ChebyshevTest.cheby_t01_poly_values_test(); ChebyshevTest.cheby_u_poly_values_test(); ChebyshevTest.cheby_u01_poly_values_test(); ChebyshevTest.cheby_v_poly_values_test(); ChebyshevTest.cheby_v01_poly_values_test(); ChebyshevTest.cheby_w_poly_values_test(); ChebyshevTest.cheby_w01_poly_values_test(); ChiTest.chi_values_test(); ChiTest.chi_square_cdf_values_test(); ChiTest.chi_square_pdf_values_test(); ChiTest.chi_square_noncentral_cdf_values_test(); CosineTest.ci_values_test(); CosineTest.cin_values_test(); CosineTest.cinh_values_test(); ClausenTest.clausen_values_test(); ClebschGordanTest.clebsch_gordan_values_test(); CollatzTest.collatz_count_values_test(); CosineTest.cos_values_test(); CosineTest.cos_degree_values_test(); CosineTest.cos_power_int_values_test(); CosineTest.cosh_values_test(); CotTest.cot_values_test(); ConstPressureTest.cp_values_test(); DateTest.datenum_values_test(); DawsonTest.dawson_values_test(); DebyeTest.debye1_values_test(); DebyeTest.debye2_values_test(); DebyeTest.debye3_values_test(); DebyeTest.debye4_values_test(); DedekindTest.dedekind_sum_values_test(); DielectricTest.dielectric_values_test(); DilogarithmTest.dilogarithm_values_test(); ExpIntegralTest.e1_values_test(); DateTest.easter_gregorian_values_test(); DateTest.easter_julian_values_test(); ExpIntegralTest.ei_values_test(); EllipticTest.elliptic_ea_values_test(); EllipticTest.elliptic_ek_values_test(); EllipticTest.elliptic_em_values_test(); EllipticTest.elliptic_fa_values_test(); EllipticTest.elliptic_fk_values_test(); EllipticTest.elliptic_fm_values_test(); EllipticTest.elliptic_inc_ea_values_test(); EllipticTest.elliptic_inc_ek_values_test(); EllipticTest.elliptic_inc_em_values_test(); EllipticTest.elliptic_inc_fa_values_test(); EllipticTest.elliptic_inc_fk_values_test(); EllipticTest.elliptic_inc_fm_values_test(); EllipticTest.elliptic_inc_pia_values_test(); EllipticTest.elliptic_inc_pik_values_test(); EllipticTest.elliptic_inc_pim_values_test(); EllipticTest.elliptic_pia_values_test(); EllipticTest.elliptic_pik_values_test(); EllipticTest.elliptic_pim_values_test(); ErrorFuncTest.erf_values_test(); ErrorFuncTest.erfc_values_test(); EulerTest.euler_number_values_test(); EulerTest.euler_poly_values_test(); ExponentialTest.exp_values_test(); ExponentialTest.exp3_int_values_test(); ExponentialTest.exponential_01_pdf_values_test(); ExponentialTest.exponential_cdf_values_test(); ExponentialTest.exponential_pdf_values_test(); ExtremeTest.extreme_values_cdf_values_test(); FTest.f_cdf_values_test(); FTest.f_noncentral_cdf_values_test(); FresnelTest.fresnel_cos_values_test(); FresnelTest.fresnel_sin_values_test(); FrobeniusTest.frobenius_number_data_values_test(); FrobeniusTest.frobenius_number_order_values_test(); FrobeniusTest.frobenius_number_order2_values_test(); GammaTest.gamma_values_test(); GammaTest.gamma_01_pdf_values_test(); GammaTest.gamma_cdf_values_test(); GammaTest.gamma_inc_values_test(); GammaTest.gamma_inc_p_values_test(); GammaTest.gamma_inc_q_values_test(); GammaTest.gamma_inc_tricomi_values_test(); GammaTest.gamma_log_values_test(); GammaTest.gamma_pdf_values_test(); GegenbauerTest.gegenbauer_poly_values_test(); GeometricTest.geometric_cdf_values_test(); GoodwinTest.goodwin_values_test(); GudermannianTest.gud_values_test(); HermiteTest.hermite_function_values_test(); HermiteTest.hermite_poly_phys_values_test(); HermiteTest.hermite_poly_prob_values_test(); HyperTest.hyper_1f1_values_test(); HyperTest.hyper_2f1_values_test(); HyperTest.hypergeometric_cdf_values_test(); HyperTest.hypergeometric_pdf_values_test(); HyperTest.hypergeometric_u_values_test(); ITest.i0ml0_values_test(); ITest.i1ml1_values_test(); FactorialTest.i4_factorial_values_test(); FactorialTest.i4_factorial2_values_test(); FactorialTest.i4_fall_values_test(); FactorialTest.i4_rise_values_test(); IntgrTest.int_values_test(); ChiTest.inverse_chi_square_pdf_values_test(); GammaTest.inverse_gamma_pdf_values_test(); JacobiTest.jacobi_cn_values_test(); JacobiTest.jacobi_dn_values_test(); JacobiTest.jacobi_poly_values_test(); JacobiTest.jacobi_sn_values_test(); DateTest.jed_ce_values_test(); DateTest.jed_mjd_values_test(); DateTest.jed_rd_values_test(); DateTest.jed_weekday_values_test(); KelvinTest.kei0_values_test(); KelvinTest.kei1_values_test(); KelvinTest.ker0_values_test(); KelvinTest.ker1_values_test(); LaguerreTest.laguerre_associated_values_test(); LaguerreTest.laguerre_general_values_test(); LaguerreTest.laguerre_polynomial_values_test(); LambertTest.lambert_w_values_test(); LaplaceTest.laplace_cdf_values_test(); LegendreTest.legendre_associated_values_test(); LegendreTest.legendre_associated_normalized_values_test(); LegendreTest.legendre_associated_normalized_sphere_values_test(); LegendreTest.legendre_function_q_values_test(); LegendreTest.legendre_normalized_polynomial_values_test(); LegendreTest.legendre_polynomial_values_test(); LegendreTest.legendre_shifted_polynomial_values_test(); LerchTest.lerch_values_test(); LobachevskyTest.lobachevsky_values_test(); LobattoTest.lobatto_polynomial_values_test(); LobattoTest.lobatto_polynomial_derivatives_test(); LogarithmTest.log_values_test(); LogarithmTest.log_normal_cdf_values_test(); LogarithmTest.log_series_cdf_values_test(); LogarithmTest.log10_values_test(); LogarithmTest.logarithmic_integral_values_test(); LogisticTest.logistic_cdf_values_test(); MertensTest.mertens_values_test(); MittagLefflerTest.mittag_leffler_ea_values_test(); MoebiusTest.moebius_values_test(); MultinomialTest.multinomial_pdf_values_test(); BinomialTest.negative_binomial_cdf_values_test(); WignerTest.nine_j_values_test(); NormalTest.normal_01_cdf_values_test(); NormalTest.normal_01_pdf_values_test(); NormalTest.normal_cdf_values_test(); NormalTest.normal_pdf_values_test(); OmegaTest.omega_values_test(); OwenTest.owen_values_test(); PartitionTest.partition_count_values_test(); PartitionTest.partition_distinct_count_values_test(); PhiTest.phi_values_test(); PiTest.pi_values_test(); PoissionTest.poisson_cdf_values_test(); LogarithmTest.polylogarithm_values_test(); PolyominoTest.polyomino_chiral_count_values_test(); PolyominoTest.polyomino_fixed_count_values_test(); PolyominoTest.polyomino_free_count_values_test(); PrandtlTest.prandtl_values_test(); PrimeTest.prime_values_test(); PsatTest.psat_values_test(); PsiTest.psi_values_test(); FactorialTest.r8_factorial_values_test(); FactorialTest.r8_factorial_log_values_test(); FactorialTest.r8_factorial2_values_test(); FactorialTest.r8_fall_values_test(); FactorialTest.r8_rise_values_test(); RayleighTest.rayleigh_cdf_values_test(); ChiTest.scaled_inverse_chi_square_pdf_values_test(); SecVirTest.secvir_values_test(); ShiTest.shi_values_test(); SineTest.si_values_test(); SigmaTest.sigma_values_test(); SineTest.sin_values_test(); SineTest.sin_degree_values_test(); SineTest.sin_power_int_values_test(); SineTest.sinh_values_test(); WignerTest.six_j_values_test(); SoundTest.sound_values_test(); SphereTest.sphere_unit_area_values_test(); SphereTest.sphere_unit_volume_values_test(); SphericalHarmonicTest.spherical_harmonic_values_test(); SqrtTest.sqrt_values_test(); StirlingTest.stirling1_values_test(); StirlingTest.stirling2_values_test(); StromgenTest.stromgen_values_test(); StruveTest.struve_h0_values_test(); StruveTest.struve_h1_values_test(); StruveTest.struve_l0_values_test(); StruveTest.struve_l1_values_test(); StudentTest.student_cdf_values_test(); StudentTest.student_noncentral_cdf_values_test(); FactorialTest.subfactorial_values_test(); SurfTensionTest.surten_values_test(); SynchTest.synch1_values_test(); SynchTest.synch2_values_test(); TangentTest.tan_values_test(); TangentTest.tanh_values_test(); TauTest.tau_values_test(); ThermCondTest.thercon_values_test(); WignerTest.three_j_values_test(); TransportationTest.tran02_values_test(); TransportationTest.tran03_values_test(); TransportationTest.tran04_values_test(); TransportationTest.tran05_values_test(); TransportationTest.tran06_values_test(); TransportationTest.tran07_values_test(); TransportationTest.tran08_values_test(); TransportationTest.tran09_values_test(); TrigammaTest.trigamma_values_test(); TruncatedTest.truncated_normal_ab_cdf_test(); TruncatedTest.truncated_normal_ab_pdf_test(); TruncatedTest.truncated_normal_a_cdf_test(); TruncatedTest.truncated_normal_a_pdf_test(); TruncatedTest.truncated_normal_b_cdf_test(); TruncatedTest.truncated_normal_b_pdf_test(); TsatTest.tsat_values_test(); VanDerCorputTest.van_der_corput_values_test(); ViscosityTest.viscosity_values_test(); VonMisesTest.von_mises_cdf_values_test(); DateTest.weekday_values_test(); WeibullTest.weibull_cdf_values_test(); WrightOmegaTest.wright_omega_values_test(); ZetaTest.zeta_values_test(); ZetaTest.zeta_m1_values_test(); Console.WriteLine(""); Console.WriteLine("test_values_test():"); Console.WriteLine(" Normal end of execution."); Console.WriteLine(""); }
/// <summary> /// Computes the Multiple Linear Regression Analysis. /// </summary> /// public void Compute() { int n = inputData.Length; int p = inputCount; SSt = SSe = outputMean = 0.0; // Compute the regression double[,] informationMatrix; regression.Regress(inputData, outputData, out informationMatrix); // Calculate mean of the expected outputs for (int i = 0; i < outputData.Length; i++) { outputMean += outputData[i]; } outputMean /= outputData.Length; // Calculate actual outputs (results) results = new double[inputData.Length]; for (int i = 0; i < inputData.Length; i++) { results[i] = regression.Compute(inputData[i]); } // Calculate SSe and SSt for (int i = 0; i < inputData.Length; i++) { double d; d = outputData[i] - results[i]; SSe += d * d; d = outputData[i] - outputMean; SSt += d * d; } // Calculate SSr SSr = SSt - SSe; // Calculate R-Squared rSquared = (SSt != 0) ? 1.0 - (SSe / SSt) : 1.0; // Calculated Adjusted R-Squared if (rSquared == 1) { rAdjusted = 1; } else { if (n - p == 1) { rAdjusted = double.NaN; } else { rAdjusted = 1.0 - (1.0 - rSquared) * ((n - 1.0) / (n - p - 1.0)); } } // Calculate Degrees of Freedom DFr = p; DFe = n - (p + 1); DFt = DFr + DFe; // Calculate Sum of Squares Mean MSe = SSe / DFe; MSr = SSr / DFr; MSt = SSt / DFt; // Calculate the F statistic ftest = new FTest(MSr / MSe, DFr, DFe); stdError = Math.Sqrt(MSe); // Create the ANOVA table List <AnovaVariationSource> table = new List <AnovaVariationSource>(); table.Add(new AnovaVariationSource(this, "Regression", SSr, DFr, MSr, ftest)); table.Add(new AnovaVariationSource(this, "Error", SSe, DFe, MSe, null)); table.Add(new AnovaVariationSource(this, "Total", SSt, DFt, MSt, null)); this.anovaTable = new AnovaSourceCollection(table); // Compute coefficient standard errors; standardErrors = new double[coefficientCount]; for (int i = 0; i < standardErrors.Length; i++) { standardErrors[i] = Math.Sqrt(MSe * informationMatrix[i, i]); } // Compute coefficient tests for (int i = 0; i < regression.Coefficients.Length; i++) { double tStatistic = regression.Coefficients[i] / standardErrors[i]; ttests[i] = new TTest(estimatedValue: regression.Coefficients[i], standardError: standardErrors[i], degreesOfFreedom: DFe); ftests[i] = new FTest(tStatistic * tStatistic, 1, DFe); confidences[i] = ttests[i].GetConfidenceInterval(confidencePercent); } // Compute model performance tests ttest = new TTest(results, outputMean); ztest = new ZTest(results, outputMean); chiSquareTest = new ChiSquareTest(outputData, results, n - p - 1); }
/// <summary> /// Afegeix un test final a aquest grup. /// </summary> /// <param name="descripcio">La descripció del test final</param> /// <param name="test">El cos del test</param> public void NouTest(string descripcio, FTest test) { Test nou = new Test(descripcio, this, test); membres.Add(nou); mostrador.NouTest(nou); }