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)));
}
public void Reset() {
n = 0;
correctlyClassified = 0;
errorState = OnlineCalculatorError.InsufficientElementsAdded;
}
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 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 void Reset() {
n = 0;
errorState = OnlineCalculatorError.InsufficientElementsAdded;
varianceErrorState = OnlineCalculatorError.InsufficientElementsAdded;
}
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);
}
}
