Dev/start5 (#67)

* Change to .NET Standard 2.0. Make structs readonly. Start to rip out statistics container classes. Add ChebyshevU. Add Benford and SkewNormal distributions.

* Beta use unit interval. no Sample, and other cleanup.

* Many mostly small improvements to accuracy and added tests.

Author: dcwuser

Numerics/Analysis/EvaluationSettings.cs

@@ -5,18 +5,18 @@
 namespace Meta.Numerics.Analysis {
 
     /// <summary>
-    /// Contains settings governing the evaluation of a function.
+    /// Contains settings governing the evaluation of a function by a solver.
     /// </summary>
     /// <remarks>
     /// <para>Negative values of <see cref="EvaluationBudget"/>,
     /// <see cref="RelativePrecision"/>, and <see cref="AbsolutePrecision"/>
-    /// indicate that the analysis method should use its defaults for
-    /// that property. Override the default for a property by
+    /// indicate that the solver method should use its defaults for
+    /// that property. You can override the default for a property by
     /// setting it explicitly. If you set values for some properties
     /// but not others, your setting will be applied to the property
     /// you set and the others will use defaults.</para>
-    /// <para>When an analysis method returns an <see cref="EvaluationResult"/>
-    /// object, its evaluation setting object will contain the specific
+    /// <para>When a solver method returns an <see cref="EvaluationResult"/>,
+    /// its evaluation setting object will contain the specific
     /// settings used, so you can see which default values were applied.</para>
     /// </remarks>
     public class EvaluationSettings {

Numerics/Analysis/FunctionMath.cs

@@ -17,9 +17,6 @@ namespace Meta.Numerics.Analysis {
     /// </remarks>
     public static partial class FunctionMath {
 
-        // logic for finding function points is in other classes
-
-        private static readonly double AbsolutePrecision = Math.Pow(2.0, -192);
 
     }
 

Numerics/Analysis/FunctionMath_Extrema.cs

@@ -72,7 +72,7 @@ public static Extremum FindMaximum (Func<double, double> f, double x) {
         public static Extremum FindMaximum (Func<double, double> f, double x, ExtremumSettings settings) {
             if (f == null) throw new ArgumentNullException(nameof(f));
             if (settings == null) throw new ArgumentNullException(nameof(settings));
-            return (FindMinimum(new Functor(f, true), x, settings).Negate());
+            return (FindMinimum(new Functor(u => -f(u)), x, settings).Negate());
         }
 
         /// <summary>
@@ -216,7 +216,7 @@ public static Extremum FindMaximum (Func<double, double> f, Interval r) {
         public static Extremum FindMaximum (Func<double, double> f, Interval r, ExtremumSettings settings) {
             if (f == null) throw new ArgumentNullException(nameof(f));
             if (settings == null) throw new ArgumentNullException(nameof(settings));
-            return (FindMinimum(new Functor(f, true), r.LeftEndpoint, r.RightEndpoint, settings).Negate());
+            return (FindMinimum(new Functor(x => -f(x)), r.LeftEndpoint, r.RightEndpoint, settings).Negate());
         }
 
         /// <summary>
@@ -482,34 +482,6 @@ private static void ParabolicFit (
     }
 
 
-    // This class is used to wrap a function, storing some associated state such as the evaluation count.
-    // It isn't truly a functor in the C++ sense, since .NET doesn't allow () to be overloaded, but
-    // it is a functor in the sense that it is a class used to represent a function.
-
-    internal class Functor {
-
-        public Functor (Func<double, double> f) : this(f, false) {}
-
-        public Functor (Func<double, double> f, bool negate) {
-            Function = f;
-            Negate = negate;
-        }
-
-        public Func<double, double> Function { get; protected set; }
-
-        public int EvaluationCount { get; protected set; }
-
-        public bool Negate { get; set; }
-
-        public virtual double Evaluate (double x) {
-
-            double f = Function(x);
-            if (Negate) f = -f;
-            EvaluationCount++;
-            return (f);
-
-        }
-
-    }
+    
 
 }

Numerics/Analysis/FunctionMath_Integrate.cs

@@ -28,7 +28,7 @@ public static partial class FunctionMath {
         /// </remarks>
         public static IntegrationResult Integrate(Func<double, double> integrand, double start, double end) {
             IntegrationSettings settings = new IntegrationSettings();
-            return (Integrate(integrand, start, end, settings));
+            return Integrate(integrand, start, end, settings);
         }
 
         /// <summary>
@@ -50,7 +50,7 @@ public static IntegrationResult Integrate(Func<double, double> integrand, double
         /// </remarks>
         public static IntegrationResult Integrate (Func<double, double> integrand, Interval range) {
             IntegrationSettings settings = new IntegrationSettings();
-            return (Integrate(integrand, range, settings));
+            return Integrate(integrand, range, settings);
         }
 
         internal static IntegrationSettings SetIntegrationDefaults (IntegrationSettings settings) {
@@ -76,7 +76,7 @@ internal static IntegrationSettings SetIntegrationDefaults (IntegrationSettings
         /// <para>For information, see <see cref="Integrate(Func{double, double}, double, double, IntegrationSettings)"/>.</para>
         /// </remarks>
         public static IntegrationResult Integrate (Func<double, double> integrand, Interval range, IntegrationSettings settings) {
-            return (Integrate(integrand, range.LeftEndpoint, range.RightEndpoint, settings));
+            return Integrate(integrand, range.LeftEndpoint, range.RightEndpoint, settings);
         }
 
         /// <summary>
@@ -117,8 +117,8 @@ public static IntegrationResult Integrate (Func<double, double> integrand, Inter
         /// could be determined to the required precision.</exception>
         public static IntegrationResult Integrate (Func<double,double> integrand, double start, double end, IntegrationSettings settings) {
 
-            if (integrand == null) throw new ArgumentNullException(nameof(integrand));
-            if (settings == null) throw new ArgumentNullException(nameof(settings));
+            if (integrand is null) throw new ArgumentNullException(nameof(integrand));
+            if (settings is null) throw new ArgumentNullException(nameof(settings));
 
             // Deal with right-to-left integrals
             if (end < start) {
@@ -130,29 +130,29 @@ public static IntegrationResult Integrate (Func<double,double> integrand, double
             if (Double.IsNegativeInfinity(start) && Double.IsPositiveInfinity(end)) {
                 // -\infty to +\infty
                 // remap to (-\pi/2,\pi/2)
-                Func<double, double> f1 = delegate (double t) {
+                Func<double, double> f1 = (double t) => {
                     double x = Math.Tan(t);
-                    return (integrand(x) * (1.0 + x * x));
+                    return integrand(x) * (1.0 + x * x);
                 };
-                return (Integrate(f1, -Global.HalfPI, +Global.HalfPI, settings));
+                return Integrate(f1, -Math.PI / 2.0, +Math.PI / 2.0, settings);
             } else if (Double.IsPositiveInfinity(end)) {
                 // finite to +\infty
                 // remap to interval (-1,1)
-                Func<double, double> f1 = delegate (double t) {
+                Func<double, double> f1 = (double t) => {
                     double q = 1.0 / (1.0 - t);
                     double x = start + (1.0 + t) * q;
-                    return (integrand(x) * 2.0 * q * q);
+                    return integrand(x) * 2.0 * q * q;
                 };
-                return (Integrate(f1, -1.0, +1.0, settings));
+                return Integrate(f1, -1.0, +1.0, settings);
             } else if (Double.IsNegativeInfinity(start)) {
                 // -\infty to finite
                 // remap to interval (-1,1)
-                Func<double, double> f1 = delegate (double t) {
+                Func<double, double> f1 = (double t) => {
                     double q = t + 1.0;
                     double x = end + (t - 1.0) / q;
-                    return(integrand(x) * (2.0 / q / q));
+                    return integrand(x) * (2.0 / q / q);
                 };
-                return(Integrate(f1, -1.0, +1.0, settings));
+                return Integrate(f1, -1.0, +1.0, settings);
             }
 
             // Fix settings.
@@ -162,7 +162,7 @@ public static IntegrationResult Integrate (Func<double,double> integrand, double
             Debug.Assert(end >= start);
             IAdaptiveIntegrator integrator = new GaussKronrodIntegrator(integrand, Interval.FromEndpoints(start, end));
             IntegrationResult result = Integrate_Adaptive(integrator, settings);
-            return (result);
+            return result;
         }
 
         // the drivers