public void ValidateCumulativeDistribution(double location, double scale, double dof, double x, double p) { var dist = new StudentT(location, scale, dof); Assert.That(dist.CumulativeDistribution(x), Is.EqualTo(p).Within(1e-13)); Assert.That(StudentT.CDF(location, scale, dof, x), Is.EqualTo(p).Within(1e-13)); }
/// <summary> /// Two-sided or one-sided test for whether statitics of two variables are equal in the true population, var1 and var2 are paired and dependent /// /// Hypotheses are: /// H_0: mu_var1 = mu_var2 /// H_1: mu_var1 != mu_var2 /// /// The hypotheses can be written as /// H_0: mu_var1 - mu_var2 = 0 /// H_1: mu_var1 - mu_var2 != 0 /// /// By Central Limt Theorem: /// sample_mean_var1 - sample_mean_var2 ~ N(0, SE), where null_value = 0 and SE is the standard error of the sampling distribution /// /// p-value = (sample_mean is at least ||null_value-point_estimate|| away from the null_value) | mu = null_value) /// </summary> /// <param name="sample_for_paired_data">a random sample consisting data paired together, var1 and var2, var1 and var2 are not independent</param> /// <param name="one_sided">True if the test is one-sided</param> /// <param name="significance_level"></param> /// <returns></returns> public bool RejectH0_PairedData(Tuple <double, double>[] sample_for_paired_data, out double pValue, double significance_level = 0.05, bool one_sided = false, bool useStudentT = false) { int sample_size = sample_for_paired_data.Length; double[] diff = new double[sample_size]; for (int i = 0; i < sample_size; ++i) { diff[i] = sample_for_paired_data[i].Item1 - sample_for_paired_data[i].Item2; } double point_estimate = Mean.GetMean(diff); double null_value = 0; double SE = StandardError.GetStandardError(diff); double test_statistic = System.Math.Abs(point_estimate - null_value) / SE; double percentile = 0; if (sample_for_paired_data.Length < 30 || useStudentT) //if sample size is smaller than 30, then CLT for population statistics such as sample mean no longer holds and Student's t distribution should be used in place of the normal distribution { percentile = StudentT.GetPercentile(test_statistic, sample_for_paired_data.Length - 1); } else { percentile = Gaussian.GetPercentile(test_statistic); } pValue = (1 - percentile) * (one_sided ? 1 : 2); return(pValue < significance_level); }
public void CanCreateStudentT(double location, double scale, double dof) { var n = new StudentT(location, scale, dof); AssertEx.AreEqual<double>(location, n.Location); AssertEx.AreEqual<double>(scale, n.Scale); AssertEx.AreEqual<double>(dof, n.DegreesOfFreedom); }
/// <summary> /// Get the confidence interval for the difference between two classes /// /// Note that this is for variables with continuous values /// </summary> /// <param name="sample_for_var1">random sample drawn for class 1</param> /// <param name="sample_for_var2">random sample drawn for class 2</param> /// <param name="confidence_level">confidencen level</param> /// <returns>The confidence interval for the difference between two classes in the population given the confidence level</returns> public static double[] GetConfidenceIntervalForDiff(double[] sample_for_var1, double[] sample_for_var2, double confidence_level, bool useStudentT = false, double correlation = 0) { double point_estimate, SE; LinearCombination.Diff(sample_for_var1, sample_for_var2, correlation, out point_estimate, out SE); double p1 = (1 - confidence_level) / 2; double p2 = 1 - p1; double critical_value1 = 0; double critical_value2 = 0; if (sample_for_var1.Length < 30 || sample_for_var2.Length < 30 || useStudentT) //if sample size is smaller than 30, then CLT for population statistics such as sample mean no longer holds and Student's t distribution should be used in place of the normal distribution { int df = System.Math.Min(sample_for_var1.Length - 1, sample_for_var2.Length - 1); critical_value1 = StudentT.GetQuantile(p1, df); critical_value2 = StudentT.GetQuantile(p2, df); } else { critical_value1 = Gaussian.GetQuantile(p1); critical_value2 = Gaussian.GetQuantile(p2); } return(new double[] { point_estimate + critical_value1 * SE, point_estimate + critical_value2 * SE }); }
public void CanCreateStandardStudentT() { var n = new StudentT(); AssertEx.AreEqual<double>(0.0, n.Location); AssertEx.AreEqual<double>(1.0, n.Scale); AssertEx.AreEqual<double>(1.0, n.DegreesOfFreedom); }
/// <summary> /// Return the confidence interval of the population mean (measured on a continuous random variable) given a random sample /// /// Note that this is for a variable whose values are continuous /// </summary> /// <param name="sampleMean">point estimate sample mean given by the random sample</param> /// <param name="sampleStdDev">point estimate sample standard deviation given by the random sample</param> /// <param name="sampleSize">size of the random sample</param> /// <param name="confidence_level"></param> /// <returns></returns> public static double[] GetConfidenceInterval(double sampleMean, double sampleStdDev, int sampleSize, double confidence_level, bool useStudentT = false) { double standard_error = StandardError.GetStandardError(sampleStdDev, sampleSize); double[] confidence_interval = new double[2]; double p1 = (1 - confidence_level) / 2.0; double p2 = 1 - p1; double critical_value1 = 0; double critical_value2 = 0; if (sampleSize < 30 || useStudentT) //if sample size is smaller than 30, then CLT for population statistics such as sample mean no longer holds and Student's t distribution should be used in place of the normal distribution { int df = sampleSize - 1; critical_value1 = StudentT.GetQuantile(p1, df); critical_value2 = StudentT.GetQuantile(p2, df); } else { critical_value1 = Gaussian.GetQuantile(p1); critical_value2 = Gaussian.GetQuantile(p2); } confidence_interval[0] = sampleMean + critical_value1 * standard_error; confidence_interval[1] = sampleMean + critical_value2 * standard_error; return(confidence_interval); }
public void ValidateInverseCumulativeDistribution(double location, double scale, double dof, double x, double p) { var dist = new StudentT(location, scale, dof); Assert.That(dist.InverseCumulativeDistribution(p), Is.EqualTo(x).Within(1e-6)); Assert.That(StudentT.InvCDF(location, scale, dof, p), Is.EqualTo(x).Within(1e-6)); }
public void SetDofFailsWithNonPositiveDoF(double dof) { { var n = new StudentT(); n.DegreesOfFreedom = dof; } }
public void SetScaleFailsWithNonPositiveScale(double scale) { { var n = new StudentT(); n.Scale = scale; } }
public override string ToString() { if (count < 1) { return(name + ": <no data>"); } if (times) { double total_sec = total * 1.0 / Stopwatch.Frequency; if (count == 1) { return(name + ": " + total_sec.ToString()); } double average_sec = total_sec / count; double sumsq_sec = sumsq / Stopwatch.Frequency / Stopwatch.Frequency; double variance = (sumsq_sec - total_sec * total_sec / count) / (count - 1); double stdev = Math.Sqrt(variance); double conf95 = StudentT.InvCDF(0, stdev, count - 1, 0.975) / Math.Sqrt(count); return(string.Format("Aggregate {0}: avg_usec {1} conf95plusorminus {2} stdev {3} count {4} sum {5}", name, average_sec * Math.Pow(10, 6), conf95 * Math.Pow(10, 6), stdev * Math.Pow(10, 6), count, total_sec * Math.Pow(10, 6))); } else { if (count == 1) { return(total.ToString()); } double average = total * 1.0 / count; double variance = (sumsq - (total * 1.0 * total) / count) / (count - 1); double stdev = Math.Sqrt(variance); double conf95 = StudentT.InvCDF(0, stdev, count - 1, 0.975) / Math.Sqrt(count); return(string.Format("Aggregate {0}: avg_usec {1} conf95plusorminus {2} stdev {3} count {4} sum {5}", name, average * Math.Pow(10, 6), conf95 * Math.Pow(10, 6), stdev * Math.Pow(10, 6), count, total * Math.Pow(10, 6))); } }
public void CanCreateStudentT([Values(0.0, -5.0, 10.0)] double location, [Values(0.1, 1.0, 10.0)] double scale, [Values(1.0, 3.0, Double.PositiveInfinity)] double dof) { var n = new StudentT(location, scale, dof); Assert.AreEqual(location, n.Location); Assert.AreEqual(scale, n.Scale); Assert.AreEqual(dof, n.DegreesOfFreedom); }
public void CanSampleSequence() { var n = new StudentT(); var ied = n.Samples(); ied.Take(5).ToArray(); }
public void ValidateToString() { System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; var n = new StudentT(1.0, 2.0, 1.0); Assert.AreEqual("StudentT(μ = 1, σ = 2, ν = 1)", n.ToString()); }
public Distribution(String DistributionName, params double[] vs) // 构造函数 根据名字初始化分布 { switch (DistributionName.ToUpper()) { case "NORMAL": normalDis = new Normal(vs[0], vs[1]); // double mean, double stddev break; case "CONTINUOUS": continuousUniformDis = new ContinuousUniform(vs[0], vs[1]); // int lower, int upper break; case "TRIANGULAR": triangularDis = new Triangular(vs[0], vs[1], vs[2]); //double lower, double upper, double mode (lower ≤ mode ≤ upper) break; case "STUDENTT": studentTDis = new StudentT(vs[0], vs[1], vs[2]); //double location, double scale, double freedom break; case "BERNOULLI": bernoulliDis = new Bernoulli(vs[0]); break; case "DISCRETEUNIFORM": discreteUniform = new DiscreteUniform((int)vs[0], (int)vs[1]); // int lower, int upper break; } this.DistributionName = DistributionName; }
/// <param name="degFreedom"> The number of degrees of freedom, not negative or zero </param> /// <param name="engine"> A generator of uniform random numbers, not null </param> public StudentTDistribution(double degFreedom, RandomEngine engine) { ArgChecker.isTrue(degFreedom > 0, "degrees of freedom"); ArgChecker.notNull(engine, "engine"); _degFreedom = degFreedom; _dist = new StudentT(degFreedom, engine); _beta = new InverseIncompleteBetaFunction(degFreedom / 2.0, 0.5); }
public void CanCreateStandardStudentT() { var n = new StudentT(); Assert.AreEqual <double>(0.0, n.Location); Assert.AreEqual <double>(1.0, n.Scale); Assert.AreEqual <double>(1.0, n.DegreesOfFreedom); }
public Vector <double> PValues() { Vector <double> result = TStatistics(); int df = intercept ? N - k - 1 : N - k; result.PointwiseAbs().Map(t => 2 * (1 - StudentT.CDF(0, 1, df, t)), result); return(result); }
/// <summary> /// Tau distribucija (razdioba) /// </summary> /// <param name="alfa">Nivo signifikantnosti (znacajnosti) -> 1 > alfa > 0</param> /// <param name="f">Stupanj slobode</param> /// <returns>double</returns> /// <remarks> /// <para/>Distribucija interno studentiziranih mjerenja /// <para/>Popravci i njihove standardne su korelirani /// <para/>Allan J. Pope 1976. /// </remarks> public static double Tau(double alfa, int f) { double t = StudentT.InvCDF(0, 1, f - 1, 1 - alfa / 2); double tau = t * Math.Sqrt(f) / Math.Sqrt(f - 1 + Math.Pow(t, 2)); return(tau); }
public static double[] studentT(double v1, double v2, double v3, int num) { var t = new StudentT(v1, v2, v3); double[] ret = new double[num]; t.Samples(ret); return(ret); }
public void CanCreateStudentT(double location, double scale, double dof) { var n = new StudentT(location, scale, dof); Assert.AreEqual <double>(location, n.Location); Assert.AreEqual <double>(scale, n.Scale); Assert.AreEqual <double>(dof, n.DegreesOfFreedom); }
public StudentTPrimitive(double location, double scale, double normality, Random gen) { Location = location; Scale = scale; Normality = normality; Gen = gen; dist = new StudentT(Location, Scale, Normality, Gen); }
private void CalculaICTStudent(double media, double variancia, int n, ref IntervaloConfianca ic) { StudentT ts = new StudentT(0, 1, n - 1); var percentil = ts.InverseCumulativeDistribution(0.975); ic.U = media + percentil * Math.Sqrt(variancia / n); ic.L = media - percentil * Math.Sqrt(variancia / n); }
public IList <LinearFitResult> Fit(double[] observations) { if (observations.Length != DesignMatrix.RowCount) { throw new ArgumentException("Wrong number of rows"); // Not L10N } var coefficients = QrFactorization.Solve(observations); var fittedValues = new double[observations.Length]; var residuals = new double[observations.Length]; for (int iRow = 0; iRow < observations.Length; iRow++) { var designRow = Enumerable.Range(0, DesignMatrix.ColumnCount).Select(index => DesignMatrix[iRow, index]).ToArray(); fittedValues[iRow] = DotProduct(designRow, coefficients); residuals[iRow] = observations[iRow] - fittedValues[iRow]; } double rss = DotProduct(residuals, residuals); int degreesOfFreedom = observations.Length - QrFactorization.NumberIndependentColumns; double resVar = rss / degreesOfFreedom; double sigma = Math.Sqrt(resVar); var covarianceUnscaled = MatrixCrossproductInverse; var scaledCovariance = covarianceUnscaled.Multiply(sigma * sigma); var indepColIndexes = QrFactorization.IndependentColumnIndexes.ToArray(); var result = new List <LinearFitResult>(); foreach (var contrastRow in ContrastValues.EnumerateRows()) { double standardError = 0; for (int iRow = 0; iRow < indepColIndexes.Length; iRow++) { for (int iCol = 0; iCol < indepColIndexes.Length; iCol++) { standardError += contrastRow[indepColIndexes[iRow]] * scaledCovariance[iRow, iCol] * contrastRow[indepColIndexes[iCol]]; } } standardError = Math.Sqrt(standardError); double foldChange = DotProduct(coefficients, contrastRow); double tValue = foldChange / standardError; double pValue; if (0 != degreesOfFreedom) { var studentT = new StudentT(0, 1.0, degreesOfFreedom); pValue = (1 - studentT.CumulativeDistribution(Math.Abs(tValue))) * 2; } else { pValue = 1; } result.Add(new LinearFitResult(foldChange) .SetDegreesOfFreedom(degreesOfFreedom) .SetTValue(tValue) .SetStandardError(standardError) .SetPValue(pValue)); } return(result); }
public void ValidateMedian( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.0, 10.0, -5.0, 0.0)] double location, [Values(1.0, 0.1, 1.0, 10.0, 10.0, 10.0, 10.0, 1.0, 1.0, 100.0, Double.PositiveInfinity)] double scale, [Values(1.0, 1.0, 3.0, 1.0, 2.0, 2.5, Double.PositiveInfinity, 1.0, 2.5, 1.5, 1.0)] double dof) { var n = new StudentT(location, scale, dof); Assert.AreEqual(location, n.Median); }
/// <summary> /// Return the confidence interval of the population mean at a given confidence level, given the point estimate sample mean are known from multiple groups / classes /// /// Note that each class should be a continuous variable. /// </summary> /// <param name="sampleMeans">point estimate sample means from different groups/classes</param> /// <param name="sampleStdDev">point estimate sample standard deviations from different groups / classes</param> /// <param name="sampleSizes">sample size from different classes</param> /// <param name="confidence_level">The given confidence level</param> /// <param name="useStudentT">whether student t should be used for test statistic</param> /// <returns>The confidence level of the population mean at the given confidence level</returns> public static double[] GetConfidenceInterval(double[] sampleMeans, double[] sampleStdDev, int[] sampleSizes, double confidence_level, bool useStudentT = false) { double[] standardErrors = new double[sampleMeans.Length]; for (int i = 0; i < sampleMeans.Length; ++i) { standardErrors[i] = StandardError.GetStandardError(sampleStdDev[i], sampleSizes[i]); } double standardError = StandardError.GetStandardErrorForWeightAverages(sampleSizes, standardErrors); double sampleMean = Mean.GetMeanForWeightedAverage(sampleMeans, sampleSizes); double p1 = (1 - confidence_level) / 2.0; double p2 = 1 - p1; bool shouldUseStudentT = useStudentT; if (!shouldUseStudentT) { for (int i = 0; i < sampleSizes.Length; ++i) { if (sampleSizes[i] < 30) { shouldUseStudentT = true; break; } } } double critical_value1 = 0; double critical_value2 = 0; if (shouldUseStudentT) { int smallestSampleSize = int.MaxValue; for (int i = 0; i < sampleSizes.Length; ++i) { if (sampleSizes[i] < smallestSampleSize) { smallestSampleSize = sampleSizes[i]; } } int df = smallestSampleSize - 1; critical_value1 = StudentT.GetQuantile(p1, df); critical_value2 = StudentT.GetQuantile(p2, df); } else { critical_value1 = Gaussian.GetQuantile(p1); critical_value2 = Gaussian.GetQuantile(p2); } double[] confidence_interval = new double[2]; confidence_interval[0] = sampleMean + critical_value1 * standardError; confidence_interval[1] = sampleMean + critical_value2 * standardError; return(confidence_interval); }
public void ValidateVariance( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.0, 10.0, -5.0, 0.0)] double location, [Values(1.0, 0.1, 1.0, 10.0, 10.0, 10.0, 10.0, 1.0, 1.0, 100.0, Double.PositiveInfinity)] double scale, [Values(1.0, 1.0, 3.0, 1.0, 2.0, 2.5, Double.PositiveInfinity, 1.0, 2.5, 1.5, 1.0)] double dof, [Values(Double.NaN, Double.NaN, 3.0, Double.NaN, Double.PositiveInfinity, 500.0, 100.0, Double.NaN, 5.0, Double.PositiveInfinity, Double.NaN)] double var) { var n = new StudentT(location, scale, dof); Assert.AreEqual(var, n.Variance); }
public void ValidateStdDev( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.0, 10.0, -5.0, 0.0)] double location, [Values(1.0, 0.1, 1.0, 10.0, 10.0, 10.0, 10.0, 1.0, 1.0, 100.0, Double.PositiveInfinity)] double scale, [Values(1.0, 1.0, 3.0, 1.0, 2.0, 2.5, Double.PositiveInfinity, 1.0, 2.5, 1.5, 1.0)] double dof, [Values(Double.NaN, Double.NaN, 1.7320508075688772935274463415059, Double.NaN, Double.PositiveInfinity, 22.360679774997896964091736687313, 10.0, Double.NaN, 2.2360679774997896964091736687313, Double.PositiveInfinity, Double.NaN)] double sdev) { var n = new StudentT(location, scale, dof); Assert.AreEqual(sdev, n.StdDev); }
public void ValidateCumulativeDistribution( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)] double location, [Values(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)] double scale, [Values(1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity)] double dof, [Values(0.0, 1.0, -1.0, 2.0, -2.0, 0.0, 1.0, -1.0, 2.0, -2.0, 0.0, 1.0, 2.0)] double x, [Values(0.5, 0.75, 0.25, 0.852416382349567, 0.147583617650433, 0.5, 0.788675134594813, 0.211324865405187, 0.908248290463863, 0.091751709536137, 0.5, 0.841344746068543, 0.977249868051821)] double c) { var n = new StudentT(location, scale, dof); AssertHelpers.AlmostEqual(c, n.CumulativeDistribution(x), 13); }
public double GetMeanErrorAt(double confidence) { if (GetN() <= 2) { return(Double.NaN); } var distribution = new StudentT(0, 1, GetN() - 1); double a = distribution.InverseCumulativeDistribution(1 - (1 - confidence) / 2); return(a * GetStandardDeviation() / Math.Sqrt(GetN())); }
public void ValidateDensityLn( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)] double location, [Values(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)] double scale, [Values(1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity)] double dof, [Values(0.0, 1.0, -1.0, 2.0, -2.0, 0.0, 1.0, -1.0, 2.0, -2.0, 0.0, 1.0, 2.0)] double x, [Values(-1.144729885849399, -1.837877066409348, -1.837877066409348, -2.754167798283503, -2.754167798283503, -1.039720770839917, -1.647918433002166, -1.647918433002166, -2.687639203842085, -2.687639203842085, -0.918938533204672, -1.418938533204674, -2.918938533204674)] double p) { var n = new StudentT(location, scale, dof); AssertHelpers.AlmostEqual(p, n.DensityLn(x), 13); }
public void ValidateDensity( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)] double location, [Values(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)] double scale, [Values(1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0, Double.PositiveInfinity, Double.PositiveInfinity, Double.PositiveInfinity)] double dof, [Values(0.0, 1.0, -1.0, 2.0, -2.0, 0.0, 1.0, -1.0, 2.0, -2.0, 0.0, 1.0, 2.0)] double x, [Values(0.318309886183791, 0.159154943091895, 0.159154943091895, 0.063661977236758, 0.063661977236758, 0.353553390593274, 0.192450089729875, 0.192450089729875, 0.068041381743977, 0.068041381743977, 0.398942280401433, 0.241970724519143, 0.053990966513188)] double p) { var n = new StudentT(location, scale, dof); AssertHelpers.AlmostEqual(p, n.Density(x), 13); }
//[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")] public static double TDist(double x, int degreesFreedom, int tails) { switch (tails) { case 1: return 1d - StudentT.CDF(0d, 1d, degreesFreedom, x); case 2: return 1d - StudentT.CDF(0d, 1d, degreesFreedom, x) + StudentT.CDF(0d, 1d, degreesFreedom, -x); default: throw new ArgumentOutOfRangeException("tails"); } }
public void ValidateMinimum() { var n = new StudentT(); Assert.AreEqual(Double.NegativeInfinity, n.Minimum); }
public void ValidateMode( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.0, 10.0, -5.0, 0.0)] double location, [Values(1.0, 0.1, 1.0, 10.0, 10.0, 10.0, 10.0, 1.0, 1.0, 100.0, Double.PositiveInfinity)] double scale, [Values(1.0, 1.0, 3.0, 1.0, 2.0, 2.5, Double.PositiveInfinity, 1.0, 2.5, 1.5, 1.0)] double dof) { var n = new StudentT(location, scale, dof); Assert.AreEqual(location, n.Mode); }
public void CanSampleSequence() { var n = new StudentT(); var ied = n.Samples(); var e = ied.Take(5).ToArray(); }
public void ValidateCumulativeDistribution(double location, double scale, double dof, double x, double c) { var n = new StudentT(location, scale, dof); AssertHelpers.AlmostEqual(c, n.CumulativeDistribution(x), 13); }
public void ValidateToString() { var n = new StudentT(1.0, 2.0, 1.0); AssertEx.AreEqual<string>("StudentT(Location = 1, Scale = 2, DoF = 1)", n.ToString()); }
public void ValidateVariance(double location, double scale, double dof, double var) { var n = new StudentT(location, scale, dof); AssertEx.AreEqual<double>(var, n.Variance); }
public void ValidateMode(double location, double scale, double dof) { var n = new StudentT(location, scale, dof); AssertEx.AreEqual<double>(location, n.Mode); }
public void ValidateStdDev(double location, double scale, double dof, double sdev) { var n = new StudentT(location, scale, dof); AssertEx.AreEqual<double>(sdev, n.StdDev); }
public void ValidateMinimum() { var n = new StudentT(); AssertEx.AreEqual<double>(System.Double.NegativeInfinity, n.Minimum); }
public void ValidateMean(double location, double scale, double dof, double mean) { var n = new StudentT(location, scale, dof); AssertEx.AreEqual<double>(mean, n.Mean); }
public void ValidateDensityLn(double location, double scale, double dof, double x, double p) { var n = new StudentT(location, scale, dof); AssertHelpers.AlmostEqual(p, n.DensityLn(x), 13); }
public void ValidateMean( [Values(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.0, -5.0, 0.0)] double location, [Values(1.0, 0.1, 1.0, 10.0, 10.0, 10.0, 1.0, 100.0, Double.PositiveInfinity)] double scale, [Values(1.0, 1.0, 3.0, 1.0, 2.0, Double.PositiveInfinity, 1.0, 1.5, 1.0)] double dof, [Values(Double.NaN, Double.NaN, 0.0, Double.NaN, 0.0, 0.0, Double.NaN, -5.0, Double.NaN)] double mean) { var n = new StudentT(location, scale, dof); Assert.AreEqual(mean, n.Mean); }
public void ValidateMaximum() { var n = new StudentT(); Assert.AreEqual(Double.PositiveInfinity, n.Maximum); }
public void SetDofFailsWithNonPositiveDoF([Values(-1.0, -0.0, 0.0)] double dof) { var n = new StudentT(); Assert.Throws<ArgumentOutOfRangeException>(() => n.DegreesOfFreedom = dof); }
public void StudentTCreateFailsWithBadParameters(double location, double scale, double dof) { var n = new StudentT(location, scale, dof); }
public void SetScaleFailsWithNonPositiveScale([Values(-1.0, -0.0, 0.0)] double scale) { var n = new StudentT(); Assert.Throws<ArgumentOutOfRangeException>(() => n.Scale = scale); }
public void CanSetLocation(double loc) { var n = new StudentT(); n.Location = loc; }
public void CanSetScale(double scale) { var n = new StudentT(); n.Scale = scale; }
public void CanSample() { var n = new StudentT(); var d = n.Sample(); }
public void CanSetDoF(double dof) { var n = new StudentT(); n.DegreesOfFreedom = dof; }