diff --git a/src/FSharp.Tests/FitTests.fs b/src/FSharp.Tests/FitTests.fs index e3e857d2..35ca135e 100644 --- a/src/FSharp.Tests/FitTests.fs +++ b/src/FSharp.Tests/FitTests.fs @@ -18,7 +18,7 @@ module FitTests = let y = x |> Array.map f // LeastSquares.FitToLine(x,y) - let a, b = Fit.line x y + let struct (a, b) = Fit.line x y a |> should (equalWithin 1.0e-12) 4.0 b |> should (equalWithin 1.0e-12) -1.5 @@ -35,7 +35,7 @@ module FitTests = let y = [| 4.986; 2.347; 2.061; -2.995; -2.352; -5.782 |] // LeastSquares.FitToLinearCombination(x, y, (fun z -> 1.0), (fun z -> Math.Sin(z)), (fun z -> Math.Cos(z))) - let [a;b;c] = (x,y) ||> Fit.linear [(fun _ -> 1.0); (Math.Sin); (Math.Cos)] + let [a;b;c] = (x,y) ||> Fit.linear [(fun _ -> 1.0); Math.Sin; Math.Cos] a |> should (equalWithin 1.0e-4) -0.287476 b |> should (equalWithin 1.0e-4) 4.02159 c |> should (equalWithin 1.0e-4) -1.46962 diff --git a/src/Numerics.Tests/OptimizationTests/NewtonMinimizerTests.cs b/src/Numerics.Tests/OptimizationTests/NewtonMinimizerTests.cs index 17045644..ab8ce7f8 100644 --- a/src/Numerics.Tests/OptimizationTests/NewtonMinimizerTests.cs +++ b/src/Numerics.Tests/OptimizationTests/NewtonMinimizerTests.cs @@ -101,7 +101,7 @@ namespace MathNet.Numerics.UnitTests.OptimizationTests [Test] public void FindMinimum_Rosenbrock_Hard() { - var obj = ObjectiveFunction.GradientHessian(point => Tuple.Create(RosenbrockFunction.Value(point), RosenbrockFunction.Gradient(point), RosenbrockFunction.Hessian(point))); + var obj = ObjectiveFunction.GradientHessian(point => (RosenbrockFunction.Value(point), RosenbrockFunction.Gradient(point), RosenbrockFunction.Hessian(point))); var solver = new NewtonMinimizer(1e-5, 1000); var result = solver.FindMinimum(obj, new DenseVector(new[] { -1.2, 1.0 })); diff --git a/src/Numerics/Complex32.cs b/src/Numerics/Complex32.cs index e09c7fc5..13dedc34 100644 --- a/src/Numerics/Complex32.cs +++ b/src/Numerics/Complex32.cs @@ -489,22 +489,21 @@ namespace MathNet.Numerics /// /// Evaluate all square roots of this Complex32. /// - public Tuple SquareRoots() + public (Complex32, Complex32) SquareRoots() { var principal = SquareRoot(); - return new Tuple(principal, -principal); + return (principal, -principal); } /// /// Evaluate all cubic roots of this Complex32. /// - public Tuple CubicRoots() + public (Complex32, Complex32, Complex32) CubicRoots() { float r = (float)Math.Pow(Magnitude, 1d / 3d); float theta = Phase / 3; const float shift = (float)Constants.Pi2 / 3; - return new Tuple( - FromPolarCoordinates(r, theta), + return (FromPolarCoordinates(r, theta), FromPolarCoordinates(r, theta + shift), FromPolarCoordinates(r, theta - shift)); } diff --git a/src/Numerics/ComplexExtensions.cs b/src/Numerics/ComplexExtensions.cs index da4d0c1a..20672ec8 100644 --- a/src/Numerics/ComplexExtensions.cs +++ b/src/Numerics/ComplexExtensions.cs @@ -295,22 +295,21 @@ namespace MathNet.Numerics /// /// Evaluate all square roots of this Complex. /// - public static Tuple SquareRoots(this Complex complex) + public static (Complex, Complex) SquareRoots(this Complex complex) { var principal = SquareRoot(complex); - return new Tuple(principal, -principal); + return (principal, -principal); } /// /// Evaluate all cubic roots of this Complex. /// - public static Tuple CubicRoots(this Complex complex) + public static (Complex, Complex, Complex) CubicRoots(this Complex complex) { var r = Math.Pow(complex.Magnitude, 1d/3d); var theta = complex.Phase/3; const double shift = Constants.Pi2/3; - return new Tuple( - Complex.FromPolarCoordinates(r, theta), + return (Complex.FromPolarCoordinates(r, theta), Complex.FromPolarCoordinates(r, theta + shift), Complex.FromPolarCoordinates(r, theta - shift)); } diff --git a/src/Numerics/FindMinimum.cs b/src/Numerics/FindMinimum.cs index b0f41c8a..3ae6645e 100644 --- a/src/Numerics/FindMinimum.cs +++ b/src/Numerics/FindMinimum.cs @@ -3,7 +3,7 @@ // http://numerics.mathdotnet.com // http://github.com/mathnet/mathnet-numerics // -// Copyright (c) 2009-2017 Math.NET +// Copyright (c) 2009-2021 Math.NET // // Permission is hereby granted, free of charge, to any person // obtaining a copy of this software and associated documentation @@ -61,44 +61,44 @@ namespace MathNet.Numerics /// Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. /// For more options and diagnostics consider to use directly. /// - public static Tuple OfFunction(Func function, double initialGuess0, double initialGuess1, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1) OfFunction(Func function, double initialGuess0, double initialGuess1, double tolerance = 1e-8, int maxIterations = 1000) { var objective = ObjectiveFunction.Value(v => function(v[0], v[1])); var result = NelderMeadSimplex.Minimum(objective, CreateVector.Dense(new[] { initialGuess0, initialGuess1 }), tolerance, maxIterations); - return Tuple.Create(result.MinimizingPoint[0], result.MinimizingPoint[1]); + return (result.MinimizingPoint[0], result.MinimizingPoint[1]); } /// /// Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. /// For more options and diagnostics consider to use directly. /// - public static Tuple OfFunction(Func function, double initialGuess0, double initialGuess1, double initialGuess2, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1, double P2) OfFunction(Func function, double initialGuess0, double initialGuess1, double initialGuess2, double tolerance = 1e-8, int maxIterations = 1000) { var objective = ObjectiveFunction.Value(v => function(v[0], v[1], v[2])); var result = NelderMeadSimplex.Minimum(objective, CreateVector.Dense(new[] { initialGuess0, initialGuess1, initialGuess2 }), tolerance, maxIterations); - return Tuple.Create(result.MinimizingPoint[0], result.MinimizingPoint[1], result.MinimizingPoint[2]); + return (result.MinimizingPoint[0], result.MinimizingPoint[1], result.MinimizingPoint[2]); } /// /// Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. /// For more options and diagnostics consider to use directly. /// - public static Tuple OfFunction(Func function, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1, double P2, double P3) OfFunction(Func function, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double tolerance = 1e-8, int maxIterations = 1000) { var objective = ObjectiveFunction.Value(v => function(v[0], v[1], v[2], v[3])); var result = NelderMeadSimplex.Minimum(objective, CreateVector.Dense(new[] { initialGuess0, initialGuess1, initialGuess2, initialGuess3 }), tolerance, maxIterations); - return Tuple.Create(result.MinimizingPoint[0], result.MinimizingPoint[1], result.MinimizingPoint[2], result.MinimizingPoint[3]); + return (result.MinimizingPoint[0], result.MinimizingPoint[1], result.MinimizingPoint[2], result.MinimizingPoint[3]); } /// /// Find vector x that minimizes the function f(x) using the Nelder-Mead Simplex algorithm. /// For more options and diagnostics consider to use directly. /// - public static Tuple OfFunction(Func function, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double initialGuess4, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1, double P2, double P3, double P4) OfFunction(Func function, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double initialGuess4, double tolerance = 1e-8, int maxIterations = 1000) { var objective = ObjectiveFunction.Value(v => function(v[0], v[1], v[2], v[3], v[4])); var result = NelderMeadSimplex.Minimum(objective, CreateVector.Dense(new[] { initialGuess0, initialGuess1, initialGuess2, initialGuess3, initialGuess4 }), tolerance, maxIterations); - return Tuple.Create(result.MinimizingPoint[0], result.MinimizingPoint[1], result.MinimizingPoint[2], result.MinimizingPoint[3], result.MinimizingPoint[4]); + return (result.MinimizingPoint[0], result.MinimizingPoint[1], result.MinimizingPoint[2], result.MinimizingPoint[3], result.MinimizingPoint[4]); } /// @@ -144,7 +144,7 @@ namespace MathNet.Numerics /// For more options and diagnostics consider to use directly. /// An alternative routine using conjugate gradients (CG) is available in . /// - public static Vector OfFunctionGradient(Func, Tuple>> functionGradient, Vector initialGuess, double gradientTolerance=1e-5, double parameterTolerance=1e-5, double functionProgressTolerance=1e-5, int maxIterations=1000) + public static Vector OfFunctionGradient(Func, (double, Vector)> functionGradient, Vector initialGuess, double gradientTolerance=1e-5, double parameterTolerance=1e-5, double functionProgressTolerance=1e-5, int maxIterations=1000) { var objective = ObjectiveFunction.Gradient(functionGradient); var algorithm = new BfgsMinimizer(gradientTolerance, parameterTolerance, functionProgressTolerance, maxIterations); @@ -168,7 +168,7 @@ namespace MathNet.Numerics /// Find vector x that minimizes the function f(x), constrained within bounds, using the Broyden–Fletcher–Goldfarb–Shanno Bounded (BFGS-B) algorithm. /// For more options and diagnostics consider to use directly. /// - public static Vector OfFunctionGradientConstrained(Func, Tuple>> functionGradient, Vector lowerBound, Vector upperBound, Vector initialGuess, double gradientTolerance=1e-5, double parameterTolerance=1e-5, double functionProgressTolerance=1e-5, int maxIterations=1000) + public static Vector OfFunctionGradientConstrained(Func, (double, Vector)> functionGradient, Vector lowerBound, Vector upperBound, Vector initialGuess, double gradientTolerance=1e-5, double parameterTolerance=1e-5, double functionProgressTolerance=1e-5, int maxIterations=1000) { var objective = ObjectiveFunction.Gradient(functionGradient); var algorithm = new BfgsBMinimizer(gradientTolerance, parameterTolerance, functionProgressTolerance, maxIterations); @@ -191,7 +191,7 @@ namespace MathNet.Numerics /// Find vector x that minimizes the function f(x) using the Newton algorithm. /// For more options and diagnostics consider to use directly. /// - public static Vector OfFunctionGradientHessian(Func, Tuple, Matrix>> functionGradientHessian, Vector initialGuess, double gradientTolerance=1e-8, int maxIterations=1000) + public static Vector OfFunctionGradientHessian(Func, (double, Vector, Matrix)> functionGradientHessian, Vector initialGuess, double gradientTolerance=1e-8, int maxIterations=1000) { var objective = ObjectiveFunction.GradientHessian(functionGradientHessian); var result = NewtonMinimizer.Minimum(objective, initialGuess, gradientTolerance, maxIterations); diff --git a/src/Numerics/FindRoots.cs b/src/Numerics/FindRoots.cs index b9604f6e..de46f7f3 100644 --- a/src/Numerics/FindRoots.cs +++ b/src/Numerics/FindRoots.cs @@ -84,26 +84,26 @@ namespace MathNet.Numerics /// Find both complex roots of the quadratic equation c + b*x + a*x^2 = 0. /// Note the special coefficient order ascending by exponent (consistent with polynomials). /// - public static Tuple Quadratic(double c, double b, double a) + public static (Complex, Complex) Quadratic(double c, double b, double a) { if (b == 0d) { var t = new Complex(-c/a, 0d).SquareRoot(); - return new Tuple(t, -t); + return (t, -t); } var q = b > 0d ? -0.5*(b + new Complex(b*b - 4*a*c, 0d).SquareRoot()) : -0.5*(b - new Complex(b*b - 4*a*c, 0d).SquareRoot()); - return new Tuple(q/a, c/q); + return (q/a, c/q); } /// /// Find all three complex roots of the cubic equation d + c*x + b*x^2 + a*x^3 = 0. /// Note the special coefficient order ascending by exponent (consistent with polynomials). /// - public static Tuple Cubic(double d, double c, double b, double a) + public static (Complex, Complex, Complex) Cubic(double d, double c, double b, double a) { return RootFinding.Cubic.Roots(d, c, b, a); } diff --git a/src/Numerics/Fit.cs b/src/Numerics/Fit.cs index 6d7bebd2..a34a0476 100644 --- a/src/Numerics/Fit.cs +++ b/src/Numerics/Fit.cs @@ -45,7 +45,7 @@ namespace MathNet.Numerics /// returning its best fitting parameters as [a, b] array, /// where a is the intercept and b the slope. /// - public static Tuple Line(double[] x, double[] y) + public static (double A, double B) Line(double[] x, double[] y) { return SimpleRegression.Fit(x, y); } @@ -85,12 +85,12 @@ namespace MathNet.Numerics /// Least-Squares fitting the points (x,y) to an exponential y : x -> a*exp(r*x), /// returning its best fitting parameters as (a, r) tuple. /// - public static Tuple Exponential(double[] x, double[] y, DirectRegressionMethod method = DirectRegressionMethod.QR) + public static (double A, double R) Exponential(double[] x, double[] y, DirectRegressionMethod method = DirectRegressionMethod.QR) { // Transformation: y_h := ln(y) ~> y_h : x -> ln(a) + r*x; double[] lny = Generate.Map(y, Math.Log); double[] p = LinearCombination(x, lny, method, t => 1.0, t => t); - return Tuple.Create(Math.Exp(p[0]), p[1]); + return (Math.Exp(p[0]), p[1]); } /// @@ -109,11 +109,11 @@ namespace MathNet.Numerics /// Least-Squares fitting the points (x,y) to a logarithm y : x -> a + b*ln(x), /// returning its best fitting parameters as (a, b) tuple. /// - public static Tuple Logarithm(double[] x, double[] y, DirectRegressionMethod method = DirectRegressionMethod.QR) + public static (double A, double B) Logarithm(double[] x, double[] y, DirectRegressionMethod method = DirectRegressionMethod.QR) { double[] lnx = Generate.Map(x, Math.Log); double[] p = LinearCombination(lnx, y, method, t => 1.0, t => t); - return Tuple.Create(p[0], p[1]); + return (p[0], p[1]); } /// @@ -132,12 +132,12 @@ namespace MathNet.Numerics /// Least-Squares fitting the points (x,y) to a power y : x -> a*x^b, /// returning its best fitting parameters as (a, b) tuple. /// - public static Tuple Power(double[] x, double[] y, DirectRegressionMethod method = DirectRegressionMethod.QR) + public static (double A, double B) Power(double[] x, double[] y, DirectRegressionMethod method = DirectRegressionMethod.QR) { // Transformation: y_h := ln(y) ~> y_h : x -> ln(a) + b*ln(x); double[] lny = Generate.Map(y, Math.Log); double[] p = LinearCombination(x, lny, method, t => 1.0, Math.Log); - return Tuple.Create(Math.Exp(p[0]), p[1]); + return (Math.Exp(p[0]), p[1]); } /// @@ -348,7 +348,7 @@ namespace MathNet.Numerics /// Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, x), /// returning its best fitting parameter p0 and p1. /// - public static Tuple Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1) Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double tolerance = 1e-8, int maxIterations = 1000) { return FindMinimum.OfFunction((p0, p1) => Distance.Euclidean(Generate.Map(x, t => f(p0, p1, t)), y), initialGuess0, initialGuess1, tolerance, maxIterations); } @@ -357,7 +357,7 @@ namespace MathNet.Numerics /// Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, x), /// returning its best fitting parameter p0, p1 and p2. /// - public static Tuple Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1, double P2) Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double tolerance = 1e-8, int maxIterations = 1000) { return FindMinimum.OfFunction((p0, p1, p2) => Distance.Euclidean(Generate.Map(x, t => f(p0, p1, p2, t)), y), initialGuess0, initialGuess1, initialGuess2, tolerance, maxIterations); } @@ -366,7 +366,7 @@ namespace MathNet.Numerics /// Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, p3, x), /// returning its best fitting parameter p0, p1, p2 and p3. /// - public static Tuple Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1, double P2, double P3) Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double tolerance = 1e-8, int maxIterations = 1000) { return FindMinimum.OfFunction((p0, p1, p2, p3) => Distance.Euclidean(Generate.Map(x, t => f(p0, p1, p2, p3, t)), y), initialGuess0, initialGuess1, initialGuess2, initialGuess3, tolerance, maxIterations); } @@ -375,7 +375,7 @@ namespace MathNet.Numerics /// Non-linear least-squares fitting the points (x,y) to an arbitrary function y : x -> f(p0, p1, p2, p3, p4, x), /// returning its best fitting parameter p0, p1, p2, p3 and p4. /// - public static Tuple Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double initialGuess4, double tolerance = 1e-8, int maxIterations = 1000) + public static (double P0, double P1, double P2, double P3, double P4) Curve(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double initialGuess4, double tolerance = 1e-8, int maxIterations = 1000) { return FindMinimum.OfFunction((p0, p1, p2, p3, p4) => Distance.Euclidean(Generate.Map(x, t => f(p0, p1, p2, p3, p4, t)), y), initialGuess0, initialGuess1, initialGuess2, initialGuess3, initialGuess4, tolerance, maxIterations); } @@ -397,7 +397,7 @@ namespace MathNet.Numerics public static Func CurveFunc(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double tolerance = 1e-8, int maxIterations = 1000) { var parameters = Curve(x, y, f, initialGuess0, initialGuess1, tolerance, maxIterations); - return z => f(parameters.Item1, parameters.Item2, z); + return z => f(parameters.P0, parameters.P1, z); } /// @@ -407,7 +407,7 @@ namespace MathNet.Numerics public static Func CurveFunc(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double tolerance = 1e-8, int maxIterations = 1000) { var parameters = Curve(x, y, f, initialGuess0, initialGuess1, initialGuess2, tolerance, maxIterations); - return z => f(parameters.Item1, parameters.Item2, parameters.Item3, z); + return z => f(parameters.P0, parameters.P1, parameters.P2, z); } /// @@ -417,7 +417,7 @@ namespace MathNet.Numerics public static Func CurveFunc(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double tolerance = 1e-8, int maxIterations = 1000) { var parameters = Curve(x, y, f, initialGuess0, initialGuess1, initialGuess2, initialGuess3, tolerance, maxIterations); - return z => f(parameters.Item1, parameters.Item2, parameters.Item3, parameters.Item4, z); + return z => f(parameters.P0, parameters.P1, parameters.P2, parameters.P3, z); } /// @@ -427,7 +427,7 @@ namespace MathNet.Numerics public static Func CurveFunc(double[] x, double[] y, Func f, double initialGuess0, double initialGuess1, double initialGuess2, double initialGuess3, double initialGuess4, double tolerance = 1e-8, int maxIterations = 1000) { var parameters = Curve(x, y, f, initialGuess0, initialGuess1, initialGuess2, initialGuess3, initialGuess4, tolerance, maxIterations); - return z => f(parameters.Item1, parameters.Item2, parameters.Item3, parameters.Item4, parameters.Item5, z); + return z => f(parameters.P0, parameters.P1, parameters.P2, parameters.P3, parameters.P4, z); } } } diff --git a/src/Numerics/Integration/GaussRule/GaussKronrodPoint.cs b/src/Numerics/Integration/GaussRule/GaussKronrodPoint.cs index f599f94b..ec122e57 100644 --- a/src/Numerics/Integration/GaussRule/GaussKronrodPoint.cs +++ b/src/Numerics/Integration/GaussRule/GaussKronrodPoint.cs @@ -530,7 +530,7 @@ namespace MathNet.Numerics.Integration.GaussRule /// /// Return value and derivative of a Legendre series at given points. /// - static Tuple LegendreSeries(double[] a, double x) + static (double, double) LegendreSeries(double[] a, double x) { // S = a[0]*P[0, x] + ... + a[k]*P[k, x] + ... + a[n]*P[n, x] // where P[k, x] is the Legendre polynomial of order k @@ -548,9 +548,9 @@ namespace MathNet.Numerics.Integration.GaussRule // b'[k, x] = (2k + 1)/(k + 1)*b[k + 1, x] + (2k + 1)/(k + 1)*x*b'[k + 1, x] - (k + 1)/(k + 2)*b'[k + 2, x] if (a.Length == 1) - return new Tuple(a[0], 0); + return (a[0], 0); if (a.Length == 2) - return new Tuple(a[0] + a[1] * x, a[1]); + return (a[0] + a[1] * x, a[1]); double b0 = 0.0, b1 = 0.0, b2 = 0.0; double p0 = 0.0, p1 = 0.0, p2 = 0.0; @@ -568,14 +568,13 @@ namespace MathNet.Numerics.Integration.GaussRule var value = a[0] + b1 * x - 0.5 * b2; var derivative = b1 + p1 * x - 0.5 * p2; - - return new Tuple( value, derivative ); + return (value, derivative); } /// /// Return value and derivative of a Legendre polynomial of order at given points. /// - static Tuple LegendreP(int order, double x) + static (double, double) LegendreP(int order, double x) { // The Legendre polynomial, P[n, x], is defined by the recurrence relation: // @@ -590,9 +589,9 @@ namespace MathNet.Numerics.Integration.GaussRule // = (2 * n + 1) * (P[n, x] + x * P'[n, x]) - n * P'[n - 1, x] if (order == 0) - return new Tuple(1.0, 0.0); + return (1.0, 0.0); if (order == 1) - return new Tuple(x, 1.0); + return (x, 1.0); double b0 = 0.0, b1 = 1.0, b2 = 0.0; double p0 = 0.0, p1 = 0.0, p2 = 0.0; @@ -610,8 +609,7 @@ namespace MathNet.Numerics.Integration.GaussRule var value = b0; var derivative = p0; - - return new Tuple(value, derivative); + return (value, derivative); } } } diff --git a/src/Numerics/LinearRegression/SimpleRegression.cs b/src/Numerics/LinearRegression/SimpleRegression.cs index c9e25b46..a33ee77b 100644 --- a/src/Numerics/LinearRegression/SimpleRegression.cs +++ b/src/Numerics/LinearRegression/SimpleRegression.cs @@ -41,7 +41,7 @@ namespace MathNet.Numerics.LinearRegression /// /// Predictor (independent) /// Response (dependent) - public static Tuple Fit(double[] x, double[] y) + public static (double A, double B) Fit(double[] x, double[] y) { if (x.Length != y.Length) { @@ -76,7 +76,7 @@ namespace MathNet.Numerics.LinearRegression } var b = covariance/variance; - return new Tuple(my - b*mx, b); + return (my - b*mx, b); } /// @@ -85,7 +85,7 @@ namespace MathNet.Numerics.LinearRegression /// where a is the intercept and b the slope. /// /// Predictor-Response samples as tuples - public static Tuple Fit(IEnumerable> samples) + public static (double A, double B) Fit(IEnumerable> samples) { var xy = samples.UnpackSinglePass(); return Fit(xy.Item1, xy.Item2); diff --git a/src/Numerics/Optimization/ObjectiveFunction.cs b/src/Numerics/Optimization/ObjectiveFunction.cs index 8d265e61..2695d35b 100644 --- a/src/Numerics/Optimization/ObjectiveFunction.cs +++ b/src/Numerics/Optimization/ObjectiveFunction.cs @@ -46,7 +46,7 @@ namespace MathNet.Numerics.Optimization /// /// Objective function where the Gradient is available. Greedy evaluation. /// - public static IObjectiveFunction Gradient(Func, Tuple>> function) + public static IObjectiveFunction Gradient(Func, (double, Vector)> function) { return new GradientObjectiveFunction(function); } @@ -62,7 +62,7 @@ namespace MathNet.Numerics.Optimization /// /// Objective function where the Hessian is available. Greedy evaluation. /// - public static IObjectiveFunction Hessian(Func, Tuple>> function) + public static IObjectiveFunction Hessian(Func, (double, Matrix)> function) { return new HessianObjectiveFunction(function); } @@ -78,7 +78,7 @@ namespace MathNet.Numerics.Optimization /// /// Objective function where both Gradient and Hessian are available. Greedy evaluation. /// - public static IObjectiveFunction GradientHessian(Func, Tuple, Matrix>> function) + public static IObjectiveFunction GradientHessian(Func, (double, Vector, Matrix)> function) { return new GradientHessianObjectiveFunction(function); } diff --git a/src/Numerics/Optimization/ObjectiveFunctions/GradientHessianObjectiveFunction.cs b/src/Numerics/Optimization/ObjectiveFunctions/GradientHessianObjectiveFunction.cs index 3a96efeb..295ac435 100644 --- a/src/Numerics/Optimization/ObjectiveFunctions/GradientHessianObjectiveFunction.cs +++ b/src/Numerics/Optimization/ObjectiveFunctions/GradientHessianObjectiveFunction.cs @@ -34,9 +34,9 @@ namespace MathNet.Numerics.Optimization.ObjectiveFunctions { internal class GradientHessianObjectiveFunction : IObjectiveFunction { - readonly Func, Tuple, Matrix>> _function; + readonly Func, (double, Vector, Matrix)> _function; - public GradientHessianObjectiveFunction(Func, Tuple, Matrix>> function) + public GradientHessianObjectiveFunction(Func, (double, Vector, Matrix)> function) { _function = function; } @@ -65,11 +65,7 @@ namespace MathNet.Numerics.Optimization.ObjectiveFunctions public void EvaluateAt(Vector point) { Point = point; - - var result = _function(point); - Value = result.Item1; - Gradient = result.Item2; - Hessian = result.Item3; + (Value, Gradient, Hessian) = _function(point); } public Vector Point { get; private set; } diff --git a/src/Numerics/Optimization/ObjectiveFunctions/GradientObjectiveFunction.cs b/src/Numerics/Optimization/ObjectiveFunctions/GradientObjectiveFunction.cs index f5f48123..d51964bb 100644 --- a/src/Numerics/Optimization/ObjectiveFunctions/GradientObjectiveFunction.cs +++ b/src/Numerics/Optimization/ObjectiveFunctions/GradientObjectiveFunction.cs @@ -34,9 +34,9 @@ namespace MathNet.Numerics.Optimization.ObjectiveFunctions { internal class GradientObjectiveFunction : IObjectiveFunction { - readonly Func, Tuple>> _function; + readonly Func, (double, Vector)> _function; - public GradientObjectiveFunction(Func, Tuple>> function) + public GradientObjectiveFunction(Func, (double, Vector)> function) { _function = function; } @@ -64,10 +64,7 @@ namespace MathNet.Numerics.Optimization.ObjectiveFunctions public void EvaluateAt(Vector point) { Point = point; - - var result = _function(point); - Value = result.Item1; - Gradient = result.Item2; + (Value, Gradient) = _function(point); } public Vector Point { get; private set; } diff --git a/src/Numerics/Optimization/ObjectiveFunctions/HessianObjectiveFunction.cs b/src/Numerics/Optimization/ObjectiveFunctions/HessianObjectiveFunction.cs index c014e7a4..3c741404 100644 --- a/src/Numerics/Optimization/ObjectiveFunctions/HessianObjectiveFunction.cs +++ b/src/Numerics/Optimization/ObjectiveFunctions/HessianObjectiveFunction.cs @@ -34,9 +34,9 @@ namespace MathNet.Numerics.Optimization.ObjectiveFunctions { internal class HessianObjectiveFunction : IObjectiveFunction { - readonly Func, Tuple>> _function; + readonly Func, (double, Matrix)> _function; - public HessianObjectiveFunction(Func, Tuple>> function) + public HessianObjectiveFunction(Func, (double, Matrix)> function) { _function = function; } @@ -64,10 +64,7 @@ namespace MathNet.Numerics.Optimization.ObjectiveFunctions public void EvaluateAt(Vector point) { Point = point; - - var result = _function(point); - Value = result.Item1; - Hessian = result.Item2; + (Value, Hessian) = _function(point); } public Vector Point { get; private set; } diff --git a/src/Numerics/Optimization/ObjectiveFunctions/NonlinearObjectiveFunction.cs b/src/Numerics/Optimization/ObjectiveFunctions/NonlinearObjectiveFunction.cs index 3105ce23..fce4a8ea 100644 --- a/src/Numerics/Optimization/ObjectiveFunctions/NonlinearObjectiveFunction.cs +++ b/src/Numerics/Optimization/ObjectiveFunctions/NonlinearObjectiveFunction.cs @@ -265,11 +265,10 @@ namespace MathNet.Numerics.Optimization.ObjectiveFunctions public IObjectiveFunction ToObjectiveFunction() { - Tuple, Matrix> Function(Vector point) + (double, Vector, Matrix) Function(Vector point) { EvaluateAt(point); - - return new Tuple, Matrix>(Value, Gradient, Hessian); + return (Value, Gradient, Hessian); } var objective = new GradientHessianObjectiveFunction(Function); diff --git a/src/Numerics/Optimization/TrustRegion/Subproblems/Util.cs b/src/Numerics/Optimization/TrustRegion/Subproblems/Util.cs index 6cc116fa..23444f67 100644 --- a/src/Numerics/Optimization/TrustRegion/Subproblems/Util.cs +++ b/src/Numerics/Optimization/TrustRegion/Subproblems/Util.cs @@ -5,7 +5,7 @@ namespace MathNet.Numerics.Optimization.TrustRegion.Subproblems { internal static class Util { - public static Tuple FindBeta(double alpha, Vector sd, Vector gn, double delta) + public static (double, double) FindBeta(double alpha, Vector sd, Vector gn, double delta) { // Pstep is intersection of the trust region boundary // Pstep = α*Psd + β*(Pgn - α*Psd) @@ -27,9 +27,7 @@ namespace MathNet.Numerics.Optimization.TrustRegion.Subproblems var beta2 = -2.0 * c / aux; // return sorted beta - return (beta1 < beta2) - ? new Tuple(beta1, beta2) - : new Tuple(beta2, beta1); + return beta1 < beta2 ? (beta1, beta2) : (beta2, beta1); } } } diff --git a/src/Numerics/Polynomial.cs b/src/Numerics/Polynomial.cs index 9ed06cc5..44bf3280 100644 --- a/src/Numerics/Polynomial.cs +++ b/src/Numerics/Polynomial.cs @@ -624,7 +624,7 @@ namespace MathNet.Numerics /// Left polynomial /// Right polynomial /// A tuple holding quotient in first and remainder in second - public static Tuple DivideRemainder(Polynomial a, Polynomial b) + public static (Polynomial, Polynomial) DivideRemainder(Polynomial a, Polynomial b) { var bDegree = b.Degree; if (bDegree < 0) @@ -636,20 +636,20 @@ namespace MathNet.Numerics if (aDegree < 0) { // zero divided by non-zero is zero without remainder - return Tuple.Create(a, a); + return (a, a); } if (bDegree == 0) { // division by scalar - return Tuple.Create(Divide(a, b.Coefficients[0]), Zero); + return (Divide(a, b.Coefficients[0]), Zero); } if (aDegree < bDegree) { // denominator degree higher than nominator degree // quotient always be 0 and return c1 as remainder - return Tuple.Create(Zero, a); + return (Zero, a); } var c1 = a.Coefficients.ToArray(); @@ -691,7 +691,7 @@ namespace MathNet.Numerics rem[k] = c1[k]; } - return Tuple.Create(new Polynomial(quo), new Polynomial(rem)); + return (new Polynomial(quo), new Polynomial(rem)); } #endregion @@ -756,7 +756,7 @@ namespace MathNet.Numerics /// /// Right polynomial /// A tuple holding quotient in first and remainder in second - public Tuple DivideRemainder(Polynomial b) + public (Polynomial, Polynomial) DivideRemainder(Polynomial b) { return DivideRemainder(this, b); } diff --git a/src/Numerics/Precision.cs b/src/Numerics/Precision.cs index a167705c..3cc8edd3 100644 --- a/src/Numerics/Precision.cs +++ b/src/Numerics/Precision.cs @@ -446,7 +446,7 @@ namespace MathNet.Numerics /// Thrown if is smaller than zero. /// /// Tuple of the bottom and top range ends. - public static Tuple RangeOfMatchingFloatingPointNumbers(this double value, long maxNumbersBetween) + public static (double, double) RangeOfMatchingFloatingPointNumbers(this double value, long maxNumbersBetween) { // Make sure ulpDifference is non-negative if (maxNumbersBetween < 1) @@ -458,13 +458,13 @@ namespace MathNet.Numerics // return the same infinity for the range. if (double.IsInfinity(value)) { - return new Tuple(value, value); + return (value, value); } // If the value is a NaN then the range is a NaN too. if (double.IsNaN(value)) { - return new Tuple(double.NaN, double.NaN); + return (double.NaN, double.NaN); } // Translate the bit pattern of the double to an integer. @@ -498,7 +498,7 @@ namespace MathNet.Numerics // However due to the conversion way this means that the actual double value gets more negative :-S : BitConverter.Int64BitsToDouble(intValue + maxNumbersBetween); - return new Tuple(bottomRangeEnd, topRangeEnd); + return (bottomRangeEnd, topRangeEnd); } else { @@ -519,7 +519,7 @@ namespace MathNet.Numerics // the reversal at the negative end : BitConverter.Int64BitsToDouble(long.MinValue + (maxNumbersBetween - intValue)); - return new Tuple(bottomRangeEnd, topRangeEnd); + return (bottomRangeEnd, topRangeEnd); } } @@ -565,7 +565,7 @@ namespace MathNet.Numerics /// Tuple with the number of ULPS between the value and the value - relativeDifference as first, /// and the number of ULPS between the value and the value + relativeDifference as second value. /// - public static Tuple RangeOfMatchingNumbers(this double value, double relativeDifference) + public static (long, long) RangeOfMatchingNumbers(this double value, double relativeDifference) { // Make sure the relative is non-negative if (relativeDifference < 0) @@ -591,7 +591,7 @@ namespace MathNet.Numerics if (value.Equals(0)) { var v = BitConverter.DoubleToInt64Bits(relativeDifference); - return new Tuple(v, v); + return (v, v); } // Calculate the ulps for the maximum and minimum values @@ -603,7 +603,7 @@ namespace MathNet.Numerics long intValue = AsDirectionalInt64(value); // Determine the ranges - return new Tuple(Math.Abs(intValue - min), Math.Abs(max - intValue)); + return (Math.Abs(intValue - min), Math.Abs(max - intValue)); } /// diff --git a/src/Numerics/RootFinding/Cubic.cs b/src/Numerics/RootFinding/Cubic.cs index 4cb27304..77ebd03e 100644 --- a/src/Numerics/RootFinding/Cubic.cs +++ b/src/Numerics/RootFinding/Cubic.cs @@ -64,7 +64,7 @@ namespace MathNet.Numerics.RootFinding /// Find all real-valued roots of the cubic equation a0 + a1*x + a2*x^2 + x^3 = 0. /// Note the special coefficient order ascending by exponent (consistent with polynomials). /// - public static Tuple RealRoots(double a0, double a1, double a2) + public static (double, double, double) RealRoots(double a0, double a1, double a2) { double Q, R; QR(a2, a1, a0, out Q, out R); @@ -98,14 +98,14 @@ namespace MathNet.Numerics.RootFinding x3 = 2d*Math.Sqrt(-Q)*Math.Cos((theta - Constants.Pi2)/3d) + shift; } - return new Tuple(x1, x2, x3); + return (x1, x2, x3); } /// /// Find all three complex roots of the cubic equation d + c*x + b*x^2 + a*x^3 = 0. /// Note the special coefficient order ascending by exponent (consistent with polynomials). /// - public static Tuple Roots(double d, double c, double b, double a) + public static (Complex, Complex, Complex) Roots(double d, double c, double b, double a) { double A = b*b - 3*a*c; double B = 2*b*b*b - 9*a*b*c + 27*a*a*d; @@ -117,22 +117,19 @@ namespace MathNet.Numerics.RootFinding if (A == 0d) { var u = new Complex(s*b, 0d); - return new Tuple(u, u, u); + return (u, u, u); } var v = new Complex((9*a*d - b*c)/(2*A), 0d); var w = new Complex((4*a*b*c - 9*a*a*d - b*b*b)/(a*A), 0d); - return new Tuple(v, v, w); + return (v, v, w); } var C = (A == 0) ? new Complex(B, 0d).CubicRoots() : ((B + Complex.Sqrt(B*B - 4*A*A*A))/2).CubicRoots(); - return new Tuple( - s*(b + C.Item1 + A/C.Item1), - s*(b + C.Item2 + A/C.Item2), - s*(b + C.Item3 + A/C.Item3)); + return (s*(b + C.Item1 + A/C.Item1), s*(b + C.Item2 + A/C.Item2), s*(b + C.Item3 + A/C.Item3)); } } } diff --git a/src/Numerics/RootFinding/RobustNewtonRaphson.cs b/src/Numerics/RootFinding/RobustNewtonRaphson.cs index a77ac4da..02e1674c 100644 --- a/src/Numerics/RootFinding/RobustNewtonRaphson.cs +++ b/src/Numerics/RootFinding/RobustNewtonRaphson.cs @@ -171,9 +171,9 @@ namespace MathNet.Numerics.RootFinding static bool TryScanForCrossingsWithRoots(Func f, Func df, double lowerBound, double upperBound, double accuracy, int maxIterations, int subdivision, out double root) { var zeroCrossings = ZeroCrossingBracketing.FindIntervalsWithin(f, lowerBound, upperBound, subdivision); - foreach (Tuple bounds in zeroCrossings) + foreach ((double lower, double upper) in zeroCrossings) { - if (TryFindRoot(f, df, bounds.Item1, bounds.Item2, accuracy, maxIterations, subdivision, out root)) + if (TryFindRoot(f, df, lower, upper, accuracy, maxIterations, subdivision, out root)) { return true; } diff --git a/src/Numerics/RootFinding/ZeroCrossingBracketing.cs b/src/Numerics/RootFinding/ZeroCrossingBracketing.cs index 070ab3bd..cb8a875b 100644 --- a/src/Numerics/RootFinding/ZeroCrossingBracketing.cs +++ b/src/Numerics/RootFinding/ZeroCrossingBracketing.cs @@ -34,7 +34,7 @@ namespace MathNet.Numerics.RootFinding { public static class ZeroCrossingBracketing { - public static IEnumerable> FindIntervalsWithin(Func f, double lowerBound, double upperBound, int subdivisions) + public static IEnumerable<(double, double)> FindIntervalsWithin(Func f, double lowerBound, double upperBound, int subdivisions) { // TODO: Consider binary-style search instead of linear scan double fmin = f(lowerBound); @@ -42,7 +42,7 @@ namespace MathNet.Numerics.RootFinding if (Math.Sign(fmin) != Math.Sign(fmax)) { - yield return new Tuple(lowerBound, upperBound); + yield return (lowerBound, upperBound); yield break; } @@ -63,7 +63,7 @@ namespace MathNet.Numerics.RootFinding if (Math.Sign(sfmax) != sign) { - yield return new Tuple(smin, smax); + yield return (smin, smax); sign = Math.Sign(sfmax); } diff --git a/src/Numerics/Statistics/ArrayStatistics.Int32.cs b/src/Numerics/Statistics/ArrayStatistics.Int32.cs index d77524b6..91f27051 100644 --- a/src/Numerics/Statistics/ArrayStatistics.Int32.cs +++ b/src/Numerics/Statistics/ArrayStatistics.Int32.cs @@ -175,9 +175,9 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. /// /// Sample array, no sorting is assumed. - public static Tuple MeanVariance(int[] samples) + public static (double Mean, double Variance) MeanVariance(int[] samples) { - return new Tuple(Mean(samples), Variance(samples)); + return (Mean(samples), Variance(samples)); } /// @@ -186,9 +186,9 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. /// /// Sample array, no sorting is assumed. - public static Tuple MeanStandardDeviation(int[] samples) + public static (double Mean, double StandardDeviation) MeanStandardDeviation(int[] samples) { - return new Tuple(Mean(samples), StandardDeviation(samples)); + return (Mean(samples), StandardDeviation(samples)); } /// diff --git a/src/Numerics/Statistics/ArrayStatistics.Single.cs b/src/Numerics/Statistics/ArrayStatistics.Single.cs index 4fb53431..ab7a2056 100644 --- a/src/Numerics/Statistics/ArrayStatistics.Single.cs +++ b/src/Numerics/Statistics/ArrayStatistics.Single.cs @@ -271,9 +271,9 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. /// /// Sample array, no sorting is assumed. - public static Tuple MeanVariance(float[] samples) + public static (double Mean, double Variance) MeanVariance(float[] samples) { - return new Tuple(Mean(samples), Variance(samples)); + return (Mean(samples), Variance(samples)); } /// @@ -282,9 +282,9 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. /// /// Sample array, no sorting is assumed. - public static Tuple MeanStandardDeviation(float[] samples) + public static (double Mean, double StandardDeviation) MeanStandardDeviation(float[] samples) { - return new Tuple(Mean(samples), StandardDeviation(samples)); + return (Mean(samples), StandardDeviation(samples)); } /// diff --git a/src/Numerics/Statistics/ArrayStatistics.cs b/src/Numerics/Statistics/ArrayStatistics.cs index 3e7cc0b2..af55ca02 100644 --- a/src/Numerics/Statistics/ArrayStatistics.cs +++ b/src/Numerics/Statistics/ArrayStatistics.cs @@ -281,9 +281,9 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN and NaN for variance if data has less than two entries or if any entry is NaN. /// /// Sample array, no sorting is assumed. - public static Tuple MeanVariance(double[] samples) + public static (double Mean, double Variance) MeanVariance(double[] samples) { - return new Tuple(Mean(samples), Variance(samples)); + return (Mean(samples), Variance(samples)); } /// @@ -292,9 +292,9 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN and NaN for standard deviation if data has less than two entries or if any entry is NaN. /// /// Sample array, no sorting is assumed. - public static Tuple MeanStandardDeviation(double[] samples) + public static (double Mean, double StandardDeviation) MeanStandardDeviation(double[] samples) { - return new Tuple(Mean(samples), StandardDeviation(samples)); + return (Mean(samples), StandardDeviation(samples)); } /// diff --git a/src/Numerics/Statistics/Statistics.cs b/src/Numerics/Statistics/Statistics.cs index 862d9548..b45b867f 100644 --- a/src/Numerics/Statistics/Statistics.cs +++ b/src/Numerics/Statistics/Statistics.cs @@ -561,7 +561,7 @@ namespace MathNet.Numerics.Statistics /// /// The data to calculate the mean of. /// The mean of the sample. - public static Tuple MeanVariance(this IEnumerable samples) + public static (double Mean, double Variance) MeanVariance(this IEnumerable samples) { return samples is double[] array ? ArrayStatistics.MeanVariance(array) @@ -575,7 +575,7 @@ namespace MathNet.Numerics.Statistics /// /// The data to calculate the mean of. /// The mean of the sample. - public static Tuple MeanVariance(this IEnumerable samples) + public static (double Mean, double Variance) MeanVariance(this IEnumerable samples) { return samples is float[] array ? ArrayStatistics.MeanVariance(array) @@ -589,7 +589,7 @@ namespace MathNet.Numerics.Statistics /// /// The data to calculate the mean of. /// The mean of the sample. - public static Tuple MeanStandardDeviation(this IEnumerable samples) + public static (double Mean, double StandardDeviation) MeanStandardDeviation(this IEnumerable samples) { return samples is double[] array ? ArrayStatistics.MeanStandardDeviation(array) @@ -603,7 +603,7 @@ namespace MathNet.Numerics.Statistics /// /// The data to calculate the mean of. /// The mean of the sample. - public static Tuple MeanStandardDeviation(this IEnumerable samples) + public static (double Mean, double StandardDeviation) MeanStandardDeviation(this IEnumerable samples) { return samples is float[] array ? ArrayStatistics.MeanStandardDeviation(array) @@ -615,10 +615,10 @@ namespace MathNet.Numerics.Statistics /// Uses a normalizer (Bessel's correction; type 2). /// /// A subset of samples, sampled from the full population. - public static Tuple SkewnessKurtosis(this IEnumerable samples) + public static (double Skewness, double Kurtosis) SkewnessKurtosis(this IEnumerable samples) { var stats = new RunningStatistics(samples); - return new Tuple(stats.Skewness, stats.Kurtosis); + return (stats.Skewness, stats.Kurtosis); } /// @@ -626,10 +626,10 @@ namespace MathNet.Numerics.Statistics /// Does not use a normalizer and would thus be biased if applied to a subset (type 1). /// /// The full population data. - public static Tuple PopulationSkewnessKurtosis(this IEnumerable population) + public static (double Skewness, double Kurtosis) PopulationSkewnessKurtosis(this IEnumerable population) { var stats = new RunningStatistics(population); - return new Tuple(stats.PopulationSkewness, stats.PopulationKurtosis); + return (stats.PopulationSkewness, stats.PopulationKurtosis); } /// diff --git a/src/Numerics/Statistics/StreamingStatistics.cs b/src/Numerics/Statistics/StreamingStatistics.cs index 619f359c..cfe8b8a9 100644 --- a/src/Numerics/Statistics/StreamingStatistics.cs +++ b/src/Numerics/Statistics/StreamingStatistics.cs @@ -573,7 +573,7 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN, and NaN for variance if data has less than two entries or if any entry is NaN. /// /// Sample stream, no sorting is assumed. - public static Tuple MeanVariance(IEnumerable samples) + public static (double Mean, double Variance) MeanVariance(IEnumerable samples) { double mean = 0; double variance = 0; @@ -599,9 +599,7 @@ namespace MathNet.Numerics.Statistics } } - return new Tuple( - count > 0 ? mean : double.NaN, - count > 1 ? variance/(count - 1) : double.NaN); + return (count > 0 ? mean : double.NaN, count > 1 ? variance/(count - 1) : double.NaN); } /// @@ -610,7 +608,7 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN, and NaN for variance if data has less than two entries or if any entry is NaN. /// /// Sample stream, no sorting is assumed. - public static Tuple MeanVariance(IEnumerable samples) + public static (double Mean, double Variance) MeanVariance(IEnumerable samples) { return MeanVariance(samples.Select(x => (double)x)); } @@ -621,10 +619,10 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN, and NaN for standard deviation if data has less than two entries or if any entry is NaN. /// /// Sample stream, no sorting is assumed. - public static Tuple MeanStandardDeviation(IEnumerable samples) + public static (double Mean, double StandardDeviation) MeanStandardDeviation(IEnumerable samples) { var meanVariance = MeanVariance(samples); - return new Tuple(meanVariance.Item1, Math.Sqrt(meanVariance.Item2)); + return (meanVariance.Item1, Math.Sqrt(meanVariance.Item2)); } /// @@ -633,7 +631,7 @@ namespace MathNet.Numerics.Statistics /// Returns NaN for mean if data is empty or any entry is NaN, and NaN for standard deviation if data has less than two entries or if any entry is NaN. /// /// Sample stream, no sorting is assumed. - public static Tuple MeanStandardDeviation(IEnumerable samples) + public static (double Mean, double StandardDeviation) MeanStandardDeviation(IEnumerable samples) { return MeanStandardDeviation(samples.Select(x => (double)x)); }