public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) { var confusionMatrix = ConfusionMatrixCalculator.Calculate(originalValues, estimatedValues, out errorState); if (!errorState.Equals(OnlineCalculatorError.None)) { return double.NaN; } return CalculateMCC(confusionMatrix); }
public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) { IEnumerator<double> originalEnumerator = originalValues.GetEnumerator(); IEnumerator<double> estimatedEnumerator = estimatedValues.GetEnumerator(); OnlineNormalizedMeanSquaredErrorCalculator normalizedMSECalculator = new OnlineNormalizedMeanSquaredErrorCalculator(); //needed because otherwise the normalizedMSECalculator is in ErrorState.InsufficientValuesAdded if (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { double original = originalEnumerator.Current; double estimated = estimatedEnumerator.Current; normalizedMSECalculator.Add(original, estimated); } // always move forward both enumerators (do not use short-circuit evaluation!) while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { double original = originalEnumerator.Current; double estimated = estimatedEnumerator.Current; normalizedMSECalculator.Add(original, estimated); if (normalizedMSECalculator.ErrorState != OnlineCalculatorError.None) break; } // check if both enumerators are at the end to make sure both enumerations have the same length if (normalizedMSECalculator.ErrorState == OnlineCalculatorError.None && (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumeration doesn't match."); } else { errorState = normalizedMSECalculator.ErrorState; return normalizedMSECalculator.NormalizedMeanSquaredError; } }
public void Reset() { n = 0; Cn = 0.0; xMean = 0.0; yMean = 0.0; errorState = OnlineCalculatorError.InsufficientElementsAdded; }
public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> referenceContinuation, IEnumerable<double> predictedContinuation) { if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { var actualEnumerator = actualContinuation.GetEnumerator(); var predictedEnumerator = predictedContinuation.GetEnumerator(); var referenceEnumerator = referenceContinuation.GetEnumerator(); while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & referenceEnumerator.MoveNext() & ErrorState != OnlineCalculatorError.InvalidValueAdded) { double actual = actualEnumerator.Current; double predicted = predictedEnumerator.Current; double reference = referenceEnumerator.Current; if (double.IsNaN(actual) || double.IsNaN(predicted) || double.IsNaN(reference)) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { // error of predicted change double errorPredictedChange = (predicted - startValue) - (actual - startValue); squaredErrorMeanCalculator.Add(errorPredictedChange * errorPredictedChange); double errorReference = (reference - startValue) - (actual - startValue); unbiasedEstimatorMeanCalculator.Add(errorReference * errorReference); } } // check if both enumerators are at the end to make sure both enumerations have the same length if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext() || referenceEnumerator.MoveNext()) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 } } }
public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> predictedContinuation) { if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { var actualEnumerator = actualContinuation.GetEnumerator(); var predictedEnumerator = predictedContinuation.GetEnumerator(); while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & errorState != OnlineCalculatorError.InvalidValueAdded) { double actual = actualEnumerator.Current; double predicted = predictedEnumerator.Current; if (double.IsNaN(actual) || double.IsNaN(predicted)) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { double err = Math.Abs(actual - predicted); // count as correct only if the trend (positive/negative/no change) is predicted correctly if ((actual - startValue) * (predicted - startValue) > 0.0 || (actual - startValue).IsAlmost(predicted - startValue)) { correctSum += err; } else { incorrectSum += err; } n++; } } // check if both enumerators are at the end to make sure both enumerations have the same length if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext()) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 } } }
public double Calculate(IEnumerable<Tuple<double, double>> values, out OnlineCalculatorError errorState) { var calculator = new OnlinePearsonsRCalculator(); foreach (var tuple in values) { calculator.Add(tuple.Item1, tuple.Item2); if (calculator.ErrorState != OnlineCalculatorError.None) break; } errorState = calculator.ErrorState; return calculator.R; }
public void Add(double original, double estimated) { if (double.IsNaN(estimated) || double.IsInfinity(estimated) || double.IsNaN(original) || double.IsInfinity(original) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { double error = estimated - original; sae += Math.Abs(error); n++; errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 } }
public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) { var originalValuesArr = originalValues.ToArray(); var estimatedValuesArr = estimatedValues.ToArray(); if (originalValuesArr.Count() != estimatedValuesArr.Count()) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } double oe = Gini(originalValuesArr, estimatedValuesArr, out errorState); if (errorState != OnlineCalculatorError.None) return double.NaN; return oe / (Gini(originalValuesArr, originalValuesArr, out errorState)); }
public static double[] Calculate(double[] values, out OnlineCalculatorError error) { error = OnlineCalculatorError.None; if (values.Any(x => double.IsNaN(x) || double.IsInfinity(x))) { error = OnlineCalculatorError.InvalidValueAdded; return new double[0]; } double[] correlations = new double[values.Length]; alglib.corr.corrr1dcircular(values, values.Length, values, values.Length, ref correlations); return correlations; }
public void Add(double original, double estimated) { if (double.IsNaN(estimated) || double.IsInfinity(estimated) || double.IsNaN(original) || double.IsInfinity(original) || original.IsAlmost(0.0)) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { sre += Math.Abs((estimated - original) / original); n++; errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 } }
public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) { if (originalValues.Distinct().Skip(2).Any()) { // TODO: we could use ClassificationPerformanceMeasuresCalculator instead of the ConfusionMatrixCalculator below to handle multi-class problems throw new ArgumentException("F1 score can only be calculated for binary classification."); } var confusionMatrix = ConfusionMatrixCalculator.Calculate(originalValues, estimatedValues, out errorState); if (!errorState.Equals(OnlineCalculatorError.None)) { return double.NaN; } return CalculateFOne(confusionMatrix); }
public void Add(double original, double estimated) { // ignore cases where original is NaN completly if (!double.IsNaN(original)) { // increment number of observed samples n++; if (original.IsAlmost(estimated)) { // original = estimated = +Inf counts as correctly classified // original = estimated = -Inf counts as correctly classified correctlyClassified++; } errorState = OnlineCalculatorError.None; // number of (non-NaN) samples >= 1 } }
public static double CalculateSpearmansRank(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) { double rs = double.NaN; try { var original = originalValues.ToArray(); var estimated = estimatedValues.ToArray(); rs = alglib.basestat.spearmancorr2(original, estimated, original.Length); errorState = OnlineCalculatorError.None; } catch (alglib.alglibexception) { errorState = OnlineCalculatorError.InvalidValueAdded; } return rs; }
public void Add(double x, double y) { if (double.IsNaN(y) || double.IsInfinity(y) || double.IsNaN(x) || double.IsInfinity(x) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { n++; errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 // online calculation of tMean xMean = xMean + (x - xMean) / n; double delta = y - yMean; // delta = (y - yMean(n-1)) yMean = yMean + delta / n; // online calculation of covariance Cn = Cn + delta * (x - xMean); // C(n) = C(n-1) + (y - yMean(n-1)) (t - tMean(n)) } }
public static double[,] Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) { if (!originalValues.Any() || !estimatedValues.Any()) { errorState = OnlineCalculatorError.InsufficientElementsAdded; return null; } Dictionary<double, int> classValueIndexMapping = new Dictionary<double, int>(); int index = 0; foreach (double classValue in originalValues.OrderBy(x => x)) { if (!classValueIndexMapping.ContainsKey(classValue)) { classValueIndexMapping.Add(classValue, index); index++; } } int classes = classValueIndexMapping.Count; double[,] confusionMatrix = new double[classes, classes]; IEnumerator<double> originalEnumerator = originalValues.GetEnumerator(); IEnumerator<double> estimatedEnumerator = estimatedValues.GetEnumerator(); int originalIndex; int estimatedIndex; while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { if (!classValueIndexMapping.TryGetValue(originalEnumerator.Current, out originalIndex)) { errorState = OnlineCalculatorError.InvalidValueAdded; return null; } if (!classValueIndexMapping.TryGetValue(estimatedEnumerator.Current, out estimatedIndex)) { errorState = OnlineCalculatorError.InvalidValueAdded; return null; } confusionMatrix[estimatedIndex, originalIndex] += 1; } if (originalEnumerator.MoveNext() || estimatedEnumerator.MoveNext()) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } errorState = OnlineCalculatorError.None; return confusionMatrix; }
public static double Calculate(IEnumerable<double> returns, IEnumerable<double> signals, double transactionCost, out OnlineCalculatorError errorState) { IEnumerator<double> returnsEnumerator = returns.GetEnumerator(); IEnumerator<double> signalsEnumerator = signals.GetEnumerator(); OnlineSharpeRatioCalculator calculator = new OnlineSharpeRatioCalculator(transactionCost); // always move forward both enumerators (do not use short-circuit evaluation!) while (returnsEnumerator.MoveNext() & signalsEnumerator.MoveNext()) { double signal = signalsEnumerator.Current; double @return = returnsEnumerator.Current; calculator.Add(@return, signal); } // check if both enumerators are at the end to make sure both enumerations have the same length if (returnsEnumerator.MoveNext() || signalsEnumerator.MoveNext()) { throw new ArgumentException("Number of elements in first and second enumeration doesn't match."); } else { errorState = calculator.ErrorState; return calculator.SharpeRatio; } }
/// <summary> /// computes Hoeffding's dependence coefficient. /// Source: hoeffd.r from R package hmisc http://cran.r-project.org/web/packages/Hmisc/index.html /// </summary> private static double HoeffD(IEnumerable<double> xs, IEnumerable<double> ys, out OnlineCalculatorError errorState) { double[] rx = TiedRank(xs); double[] ry = TiedRank(ys); if (rx.Length != ry.Length) throw new ArgumentException("The number of elements in xs and ys does not match"); double[] rxy = TiedRank(xs, ys); int n = rx.Length; double q = 0, r = 0, s = 0; double scaling = 1.0 / (n * (n - 1)); for (int i = 0; i < n; i++) { q += (rx[i] - 1) * (rx[i] - 2) * (ry[i] - 1) * (ry[i] - 2) * scaling; r += (rx[i] - 2) * (ry[i] - 2) * rxy[i] * scaling; s += rxy[i] * (rxy[i] - 1) * scaling; } errorState = OnlineCalculatorError.None; // return 30.0 * (q - 2 * (n - 2) * r + (n - 2) * (n - 3) * s) / n / (n - 1) / (n - 2) / (n - 3) / (n - 4); double t0 = q / (n - 2) / (n - 3) / (n - 4); double t1 = 2 * r / (n - 3) / (n - 4); double t2 = s / (n - 4); return 30.0 * (t0 - t1 + t2); }
public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineCalculatorError errorState) { IEnumerator<double> firstEnumerator = first.GetEnumerator(); IEnumerator<double> secondEnumerator = second.GetEnumerator(); var calculator = new OnlinePearsonsRCalculator(); // always move forward both enumerators (do not use short-circuit evaluation!) while (firstEnumerator.MoveNext() & secondEnumerator.MoveNext()) { double original = firstEnumerator.Current; double estimated = secondEnumerator.Current; calculator.Add(original, estimated); if (calculator.ErrorState != OnlineCalculatorError.None) break; } // check if both enumerators are at the end to make sure both enumerations have the same length if (calculator.ErrorState == OnlineCalculatorError.None && (secondEnumerator.MoveNext() || firstEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in first and second enumeration doesn't match."); } else { errorState = calculator.ErrorState; return calculator.R; } }
private static double Gini(IEnumerable<double> original, IEnumerable<double> estimated, out OnlineCalculatorError errorState) { var pairs = estimated.Zip(original, (e, o) => new { e, o }) .OrderByDescending(p => p.e); if (pairs.Any()) errorState = OnlineCalculatorError.None; else errorState = OnlineCalculatorError.InsufficientElementsAdded; double giniSum = 0.0; double sumOriginal = 0.0; int n = 0; foreach (var p in pairs) { if (double.IsNaN(p.o) || double.IsNaN(p.e)) { errorState = OnlineCalculatorError.InvalidValueAdded; return double.NaN; } sumOriginal += p.o; giniSum += sumOriginal; n++; } giniSum /= sumOriginal; return (giniSum - ((n + 1) / 2.0)) / n; }
public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) { IEnumerator<double> originalEnumerator = originalValues.GetEnumerator(); IEnumerator<double> estimatedEnumerator = estimatedValues.GetEnumerator(); OnlineMaxAbsoluteErrorCalculator maeCalculator = new OnlineMaxAbsoluteErrorCalculator(); // always move forward both enumerators (do not use short-circuit evaluation!) while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { double original = originalEnumerator.Current; double estimated = estimatedEnumerator.Current; maeCalculator.Add(original, estimated); if (maeCalculator.ErrorState != OnlineCalculatorError.None) break; } // check if both enumerators are at the end to make sure both enumerations have the same length if (maeCalculator.ErrorState == OnlineCalculatorError.None && (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } else { errorState = maeCalculator.ErrorState; return maeCalculator.MaxAbsoluteError; } }
public void Add(double x) { if (double.IsNaN(x) || double.IsInfinity(x) || x > 1E13 || x < -1E13 || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; varianceErrorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { n++; // See Knuth TAOCP vol 2, 3rd edition, page 232 if (n == 1) { m_oldM = m_newM = x; m_oldS = 0.0; errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 } else { varianceErrorState = varianceErrorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 2 m_newM = m_oldM + (x - m_oldM) / n; m_newS = m_oldS + (x - m_oldM) * (x - m_newM); // set up for next iteration m_oldM = m_newM; m_oldS = m_newS; } } }
public static double Calculate(IEnumerable <double> returns, IEnumerable <double> signals, double transactionCost, out OnlineCalculatorError errorState) { IEnumerator <double> returnsEnumerator = returns.GetEnumerator(); IEnumerator <double> signalsEnumerator = signals.GetEnumerator(); OnlineSharpeRatioCalculator calculator = new OnlineSharpeRatioCalculator(transactionCost); // always move forward both enumerators (do not use short-circuit evaluation!) while (returnsEnumerator.MoveNext() & signalsEnumerator.MoveNext()) { double signal = signalsEnumerator.Current; double @return = returnsEnumerator.Current; calculator.Add(@return, signal); } // check if both enumerators are at the end to make sure both enumerations have the same length if (returnsEnumerator.MoveNext() || signalsEnumerator.MoveNext()) { throw new ArgumentException("Number of elements in first and second enumeration doesn't match."); } else { errorState = calculator.ErrorState; return(calculator.SharpeRatio); } }
/// <summary> /// computes Hoeffding's dependence coefficient. /// Source: hoeffd.r from R package hmisc http://cran.r-project.org/web/packages/Hmisc/index.html /// </summary> private static double HoeffD(IEnumerable <double> xs, IEnumerable <double> ys, out OnlineCalculatorError errorState) { double[] rx = TiedRank(xs); double[] ry = TiedRank(ys); if (rx.Length != ry.Length) { throw new ArgumentException("The number of elements in xs and ys does not match"); } double[] rxy = TiedRank(xs, ys); int n = rx.Length; double q = 0, r = 0, s = 0; double scaling = 1.0 / (n * (n - 1)); for (int i = 0; i < n; i++) { q += (rx[i] - 1) * (rx[i] - 2) * (ry[i] - 1) * (ry[i] - 2) * scaling; r += (rx[i] - 2) * (ry[i] - 2) * rxy[i] * scaling; s += rxy[i] * (rxy[i] - 1) * scaling; } errorState = OnlineCalculatorError.None; // return 30.0 * (q - 2 * (n - 2) * r + (n - 2) * (n - 3) * s) / n / (n - 1) / (n - 2) / (n - 3) / (n - 4); double t0 = q / (n - 2) / (n - 3) / (n - 4); double t1 = 2 * r / (n - 3) / (n - 4); double t2 = s / (n - 4); return(30.0 * (t0 - t1 + t2)); }
public void Calculate(IEnumerable<double> originalClassValues, IEnumerable<double> estimatedClassValues) { IEnumerator<double> originalEnumerator = originalClassValues.GetEnumerator(); IEnumerator<double> estimatedEnumerator = estimatedClassValues.GetEnumerator(); // always move forward both enumerators (do not use short-circuit evaluation!) while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { double original = originalEnumerator.Current; double estimated = estimatedEnumerator.Current; Add(original, estimated); if (ErrorState != OnlineCalculatorError.None) break; } // check if both enumerators are at the end to make sure both enumerations have the same length if (ErrorState == OnlineCalculatorError.None && (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } errorState = ErrorState; }
public void Add(double originalClassValue, double estimatedClassValue) { // ignore cases where original is NaN completely if (double.IsNaN(originalClassValue)) return; if (originalClassValue.IsAlmost(positiveClassValue) || estimatedClassValue.IsAlmost(positiveClassValue)) { //positive class/positive class estimation if (estimatedClassValue.IsAlmost(originalClassValue)) { truePositiveCount++; } else { if (estimatedClassValue.IsAlmost(positiveClassValue)) //misclassification of the negative class falsePositiveCount++; else //misclassification of the positive class falseNegativeCount++; } } else { //negative class/negative class estimation //In a multiclass classification all misclassifications of the negative class //will be treated as true negatives except on positive class estimations trueNegativeCount++; } errorState = OnlineCalculatorError.None; // number of (non-NaN) samples >= 1 }
public static double Calculate(IEnumerable<double> startValues, IEnumerable<IEnumerable<double>> actualContinuations, IEnumerable<IEnumerable<double>> predictedContinuations, out OnlineCalculatorError errorState) { IEnumerator<double> startValueEnumerator = startValues.GetEnumerator(); IEnumerator<IEnumerable<double>> actualContinuationsEnumerator = actualContinuations.GetEnumerator(); IEnumerator<IEnumerable<double>> predictedContinuationsEnumerator = predictedContinuations.GetEnumerator(); OnlineWeightedDirectionalSymmetryCalculator calculator = new OnlineWeightedDirectionalSymmetryCalculator(); // always move forward all enumerators (do not use short-circuit evaluation!) while (startValueEnumerator.MoveNext() & actualContinuationsEnumerator.MoveNext() & predictedContinuationsEnumerator.MoveNext()) { calculator.Add(startValueEnumerator.Current, actualContinuationsEnumerator.Current, predictedContinuationsEnumerator.Current); if (calculator.ErrorState != OnlineCalculatorError.None) break; } // check if all enumerators are at the end to make sure both enumerations have the same length if (calculator.ErrorState == OnlineCalculatorError.None && (startValueEnumerator.MoveNext() || actualContinuationsEnumerator.MoveNext() || predictedContinuationsEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in startValues, actualContinuations and estimatedValues predictedContinuations doesn't match."); } else { errorState = calculator.ErrorState; return calculator.WeightedDirectionalSymmetry; } }
public void Reset() { squaredErrorMeanCalculator.Reset(); unbiasedEstimatorMeanCalculator.Reset(); errorState = OnlineCalculatorError.InsufficientElementsAdded; }
public void Reset() { n = 0; correctlyClassified = 0; errorState = OnlineCalculatorError.InsufficientElementsAdded; }
/// <summary> /// Calculates alpha and beta parameters to linearly scale elements of original to the scale and location of target /// original[i] * beta + alpha /// </summary> /// <param name="original">Values that should be scaled</param> /// <param name="target">Target values to which the original values should be scaled</param> /// <param name="alpha">Additive constant for the linear scaling</param> /// <param name="beta">Multiplicative factor for the linear scaling</param> /// <param name="errorState">Flag that indicates if errors occurred in the calculation of the linea scaling parameters.</param> public static void Calculate(IEnumerable <double> original, IEnumerable <double> target, out double alpha, out double beta, out OnlineCalculatorError errorState) { OnlineLinearScalingParameterCalculator calculator = new OnlineLinearScalingParameterCalculator(); IEnumerator <double> originalEnumerator = original.GetEnumerator(); IEnumerator <double> targetEnumerator = target.GetEnumerator(); // always move forward both enumerators (do not use short-circuit evaluation!) while (originalEnumerator.MoveNext() & targetEnumerator.MoveNext()) { double originalElement = originalEnumerator.Current; double targetElement = targetEnumerator.Current; calculator.Add(originalElement, targetElement); if (calculator.ErrorState != OnlineCalculatorError.None) { break; } } // check if both enumerators are at the end to make sure both enumerations have the same length if (calculator.ErrorState == OnlineCalculatorError.None && (originalEnumerator.MoveNext() || targetEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in original and target enumeration do not match."); } else { errorState = calculator.ErrorState; alpha = calculator.Alpha; beta = calculator.Beta; } }
public static double Calculate(IEnumerable <double> startValues, IEnumerable <IEnumerable <double> > actualContinuations, IEnumerable <IEnumerable <double> > predictedContinuations, out OnlineCalculatorError errorState) { IEnumerator <double> startValueEnumerator = startValues.GetEnumerator(); IEnumerator <IEnumerable <double> > actualContinuationsEnumerator = actualContinuations.GetEnumerator(); IEnumerator <IEnumerable <double> > predictedContinuationsEnumerator = predictedContinuations.GetEnumerator(); OnlineDirectionalSymmetryCalculator dsCalculator = new OnlineDirectionalSymmetryCalculator(); // always move forward all enumerators (do not use short-circuit evaluation!) while (startValueEnumerator.MoveNext() & actualContinuationsEnumerator.MoveNext() & predictedContinuationsEnumerator.MoveNext()) { dsCalculator.Add(startValueEnumerator.Current, actualContinuationsEnumerator.Current, predictedContinuationsEnumerator.Current); if (dsCalculator.ErrorState != OnlineCalculatorError.None) { break; } } // check if all enumerators are at the end to make sure both enumerations have the same length if (dsCalculator.ErrorState == OnlineCalculatorError.None && (startValueEnumerator.MoveNext() || actualContinuationsEnumerator.MoveNext() || predictedContinuationsEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in startValues, actualContinuations and estimatedValues predictedContinuations doesn't match."); } else { errorState = dsCalculator.ErrorState; return(dsCalculator.DirectionalSymmetry); } }
public static double Calculate(IEnumerable <double> returns, IEnumerable <double> signals, double transactionCost, out OnlineCalculatorError errorState) { errorState = OnlineCalculatorError.None; return(GetProfits(returns, signals, transactionCost).Sum()); }
public static double Calculate(double startValue, IEnumerable <double> actualContinuation, IEnumerable <double> predictedContinuation, out OnlineCalculatorError errorState) { OnlineDirectionalSymmetryCalculator dsCalculator = new OnlineDirectionalSymmetryCalculator(); dsCalculator.Add(startValue, actualContinuation, predictedContinuation); errorState = dsCalculator.ErrorState; return(dsCalculator.DirectionalSymmetry); }
public void Reset() { n = 0; nCorrect = 0; errorState = OnlineCalculatorError.InsufficientElementsAdded; }
public static double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, double positiveClassValue, double classValuesMax, double classValuesMin, double definiteResidualsWeight, double positiveClassResidualsWeight, double negativeClassesResidualsWeight, out OnlineCalculatorError errorState) { IEnumerator <double> originalEnumerator = originalValues.GetEnumerator(); IEnumerator <double> estimatedEnumerator = estimatedValues.GetEnumerator(); OnlineWeightedClassificationMeanSquaredErrorCalculator calculator = new OnlineWeightedClassificationMeanSquaredErrorCalculator(positiveClassValue, classValuesMax, classValuesMin, definiteResidualsWeight, positiveClassResidualsWeight, negativeClassesResidualsWeight); // always move forward both enumerators (do not use short-circuit evaluation!) while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { double original = originalEnumerator.Current; double estimated = estimatedEnumerator.Current; calculator.Add(original, estimated); if (calculator.ErrorState != OnlineCalculatorError.None) { break; } } // check if both enumerators are at the end to make sure both enumerations have the same length if (calculator.ErrorState == OnlineCalculatorError.None && (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } else { errorState = calculator.ErrorState; return(calculator.WeightedResidualsMeanSquaredError); } }
public static double CalculateHoeffdings(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { double d = HoeffD(originalValues, estimatedValues, out errorState); if (errorState != OnlineCalculatorError.None) { return(double.NaN); } return(d); }
public static void Calculate(IEnumerable <double> x, out double mean, out double variance, out OnlineCalculatorError meanErrorState, out OnlineCalculatorError varianceErrorState) { OnlineMeanAndVarianceCalculator meanAndVarianceCalculator = new OnlineMeanAndVarianceCalculator(); foreach (double xi in x) { meanAndVarianceCalculator.Add(xi); } mean = meanAndVarianceCalculator.Mean; variance = meanAndVarianceCalculator.Variance; meanErrorState = meanAndVarianceCalculator.MeanErrorState; varianceErrorState = meanAndVarianceCalculator.VarianceErrorState; }
public static double[,] Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { if (!originalValues.Any() || !estimatedValues.Any()) { errorState = OnlineCalculatorError.InsufficientElementsAdded; return(null); } Dictionary <double, int> classValueIndexMapping = new Dictionary <double, int>(); int index = 0; foreach (double classValue in originalValues.OrderBy(x => x)) { if (!classValueIndexMapping.ContainsKey(classValue)) { classValueIndexMapping.Add(classValue, index); index++; } } int classes = classValueIndexMapping.Count; double[,] confusionMatrix = new double[classes, classes]; IEnumerator <double> originalEnumerator = originalValues.GetEnumerator(); IEnumerator <double> estimatedEnumerator = estimatedValues.GetEnumerator(); int originalIndex; int estimatedIndex; while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { if (!classValueIndexMapping.TryGetValue(originalEnumerator.Current, out originalIndex)) { errorState = OnlineCalculatorError.InvalidValueAdded; return(null); } if (!classValueIndexMapping.TryGetValue(estimatedEnumerator.Current, out estimatedIndex)) { errorState = OnlineCalculatorError.InvalidValueAdded; return(null); } confusionMatrix[estimatedIndex, originalIndex] += 1; } if (originalEnumerator.MoveNext() || estimatedEnumerator.MoveNext()) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } errorState = OnlineCalculatorError.None; return(confusionMatrix); }
public static double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { IEnumerator <double> originalEnumerator = originalValues.GetEnumerator(); IEnumerator <double> estimatedEnumerator = estimatedValues.GetEnumerator(); OnlineMeanErrorCalculator meCalculator = new OnlineMeanErrorCalculator(); // always move forward both enumerators (do not use short-circuit evaluation!) while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) { double original = originalEnumerator.Current; double estimated = estimatedEnumerator.Current; meCalculator.Add(original, estimated); if (meCalculator.ErrorState != OnlineCalculatorError.None) { break; } } // check if both enumerators are at the end to make sure both enumerations have the same length if (meCalculator.ErrorState == OnlineCalculatorError.None && (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } else { errorState = meCalculator.ErrorState; return(meCalculator.MeanError); } }
public void Reset() { n = 0; errorState = OnlineCalculatorError.InsufficientElementsAdded; varianceErrorState = OnlineCalculatorError.InsufficientElementsAdded; }
public double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { return(CalculateSpearmansRank(originalValues, estimatedValues, out errorState)); }
public static double Calculate(double startValue, IEnumerable <double> actualContinuation, IEnumerable <double> referenceContinuation, IEnumerable <double> predictedContinuation, out OnlineCalculatorError errorState) { OnlineTheilsUStatisticCalculator calculator = new OnlineTheilsUStatisticCalculator(); calculator.Add(startValue, actualContinuation, referenceContinuation, predictedContinuation); errorState = calculator.ErrorState; return(calculator.TheilsUStatistic); }
public static double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { var originalValuesArr = originalValues.ToArray(); var estimatedValuesArr = estimatedValues.ToArray(); if (originalValuesArr.Count() != estimatedValuesArr.Count()) { throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match."); } double oe = Gini(originalValuesArr, estimatedValuesArr, out errorState); if (errorState != OnlineCalculatorError.None) { return(double.NaN); } return(oe / (Gini(originalValuesArr, originalValuesArr, out errorState))); }
private static double Gini(IEnumerable <double> original, IEnumerable <double> estimated, out OnlineCalculatorError errorState) { var pairs = estimated.Zip(original, (e, o) => new { e, o }) .OrderByDescending(p => p.e); if (pairs.Any()) { errorState = OnlineCalculatorError.None; } else { errorState = OnlineCalculatorError.InsufficientElementsAdded; } double giniSum = 0.0; double sumOriginal = 0.0; int n = 0; foreach (var p in pairs) { if (double.IsNaN(p.o) || double.IsNaN(p.e)) { errorState = OnlineCalculatorError.InvalidValueAdded; return(double.NaN); } sumOriginal += p.o; giniSum += sumOriginal; n++; } giniSum /= sumOriginal; return((giniSum - ((n + 1) / 2.0)) / n); }
public static double Calculate(IEnumerable<double> returns, IEnumerable<double> signals, double transactionCost, out OnlineCalculatorError errorState) { errorState = OnlineCalculatorError.None; return GetProfits(returns, signals, transactionCost).Sum(); }
public static double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { if (originalValues.Distinct().Skip(2).Any()) { // TODO: we could use ClassificationPerformanceMeasuresCalculator instead of the ConfusionMatrixCalculator below to handle multi-class problems throw new ArgumentException("F1 score can only be calculated for binary classification."); } var confusionMatrix = ConfusionMatrixCalculator.Calculate(originalValues, estimatedValues, out errorState); if (!errorState.Equals(OnlineCalculatorError.None)) { return(double.NaN); } //only one class has been present => F1 score cannot be calculated if (confusionMatrix.GetLength(0) != 2 || confusionMatrix.GetLength(1) != 2) { return(double.NaN); } return(CalculateFOne(confusionMatrix)); }
public void Reset() { truePositiveCount = 0; falseNegativeCount = 0; trueNegativeCount = 0; falseNegativeCount = 0; errorState = OnlineCalculatorError.InsufficientElementsAdded; }
public double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { var r = OnlinePearsonsRCalculator.Calculate(originalValues, estimatedValues, out errorState); return(r * r); }
public void Reset() { n = 0; mae = double.MinValue; errorState = OnlineCalculatorError.InsufficientElementsAdded; }
public static double CalculateSpearmansRank(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { double rs = double.NaN; try { var original = originalValues.ToArray(); var estimated = estimatedValues.ToArray(); rs = alglib.basestat.spearmancorr2(original, estimated, original.Length); errorState = OnlineCalculatorError.None; } catch (alglib.alglibexception) { errorState = OnlineCalculatorError.InvalidValueAdded; } return(rs); }
public double Calculate(IEnumerable <Tuple <double, double> > values, out OnlineCalculatorError errorState) { return(HoeffD(values.Select(v => v.Item1), values.Select(v => v.Item2), out errorState)); }
public static double Calculate(IEnumerable <double> first, IEnumerable <double> second, out OnlineCalculatorError errorState) { var r = OnlinePearsonsRCalculator.Calculate(first, second, out errorState); return(r * r); }
public static double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { var confusionMatrix = ConfusionMatrixCalculator.Calculate(originalValues, estimatedValues, out errorState); if (!errorState.Equals(OnlineCalculatorError.None)) { return(double.NaN); } return(CalculateMCC(confusionMatrix)); }
public double Calculate(IEnumerable <double> originalValues, IEnumerable <double> estimatedValues, out OnlineCalculatorError errorState) { return(HoeffdingsDependenceCalculator.CalculateHoeffdings(originalValues, estimatedValues, out errorState)); }
public static void Calculate(IEnumerable<double> x, out double mean, out double variance, out OnlineCalculatorError meanErrorState, out OnlineCalculatorError varianceErrorState) { OnlineMeanAndVarianceCalculator meanAndVarianceCalculator = new OnlineMeanAndVarianceCalculator(); foreach (double xi in x) { meanAndVarianceCalculator.Add(xi); } mean = meanAndVarianceCalculator.Mean; variance = meanAndVarianceCalculator.Variance; meanErrorState = meanAndVarianceCalculator.MeanErrorState; varianceErrorState = meanAndVarianceCalculator.VarianceErrorState; }
public static double Calculate(IEnumerable <double> first, IEnumerable <double> second, out OnlineCalculatorError errorState) { IEnumerator <double> firstEnumerator = first.GetEnumerator(); IEnumerator <double> secondEnumerator = second.GetEnumerator(); OnlineCovarianceCalculator covarianceCalculator = new OnlineCovarianceCalculator(); // always move forward both enumerators (do not use short-circuit evaluation!) while (firstEnumerator.MoveNext() & secondEnumerator.MoveNext()) { double x = secondEnumerator.Current; double y = firstEnumerator.Current; covarianceCalculator.Add(x, y); if (covarianceCalculator.ErrorState != OnlineCalculatorError.None) { break; } } // check if both enumerators are at the end to make sure both enumerations have the same length if (covarianceCalculator.ErrorState == OnlineCalculatorError.None && (secondEnumerator.MoveNext() || firstEnumerator.MoveNext())) { throw new ArgumentException("Number of elements in first and second enumeration doesn't match."); } else { errorState = covarianceCalculator.ErrorState; return(covarianceCalculator.Covariance); } }