SpecialFunctions moves to Numerics, beside the interval evaluation

The routines are the compilers' today, and the numerical evaluation's fast tier is where they
are to be shared next, as asked on #1607: the interval evaluation reads no special function, so an
integrator check with erf or Ei in it falls back to the decimal evaluation. Nothing but the
namespace and the file's place changes.

Part of #1607.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Rafael-SOWNet

Sources/.editorconfig

@@ -342,7 +342,7 @@ file_header_template=\nCopyright (c) 2019-2026 Angouri.\nAngouriMath is licensed
 [AngouriMath/Core/Entity/Continuous/Number/ErrorFunctions.cs]
 file_header_template=\nCopyright (c) 2019-2026 Angouri.\nAngouriMath is licensed under MIT.\nDetails: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.\nWebsite: https://am.angouri.org.\n
 
-[AngouriMath/Functions/Compilation/SpecialFunctions.cs]
+[AngouriMath/Numerics/SpecialFunctions.cs]
 file_header_template=\nCopyright (c) 2019-2026 Angouri.\nAngouriMath is licensed under MIT.\nDetails: https://github.com/asc-community/AngouriMath/blob/master/LICENSE.md.\nWebsite: https://am.angouri.org.\n
 
 [AngouriMath/Core/Entity/Continuous/Entity.Continuous.ErrorFunctions.Classes.cs]

Sources/AngouriMath/Functions/Compilation/IntoFE/FastExpression.cs

@@ -231,31 +231,31 @@ public System.Numerics.Complex Substitute(params System.Numerics.Complex[] value
                     // In double precision, as the kernels define them.
                     // https://github.com/asc-community/AngouriMath/issues/1607
                     case InstructionType.CALL_ERF:
-                        stack.Push(Core.Compilation.SpecialFunctions.Erf(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Erf(stack.Pop()));
                         break;
                     case InstructionType.CALL_ERFC:
-                        stack.Push(Core.Compilation.SpecialFunctions.Erfc(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Erfc(stack.Pop()));
                         break;
                     case InstructionType.CALL_ERFI:
-                        stack.Push(Core.Compilation.SpecialFunctions.Erfi(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Erfi(stack.Pop()));
                         break;
                     case InstructionType.CALL_EI:
-                        stack.Push(Core.Compilation.SpecialFunctions.Ei(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Ei(stack.Pop()));
                         break;
                     case InstructionType.CALL_LI:
-                        stack.Push(Core.Compilation.SpecialFunctions.Li(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Li(stack.Pop()));
                         break;
                     case InstructionType.CALL_SI:
-                        stack.Push(Core.Compilation.SpecialFunctions.Si(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Si(stack.Pop()));
                         break;
                     case InstructionType.CALL_CI:
-                        stack.Push(Core.Compilation.SpecialFunctions.Ci(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Ci(stack.Pop()));
                         break;
                     case InstructionType.CALL_SHI:
-                        stack.Push(Core.Compilation.SpecialFunctions.Shi(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Shi(stack.Pop()));
                         break;
                     case InstructionType.CALL_CHI:
-                        stack.Push(Core.Compilation.SpecialFunctions.Chi(stack.Pop()));
+                        stack.Push(AngouriMath.Numerics.SpecialFunctions.Chi(stack.Pop()));
                         break;
                     case InstructionType.CALL_FACTORIAL:
                         // https://stackoverflow.com/a/15454784/5429648

Sources/AngouriMath/Functions/Compilation/IntoLinq/MathAllMethods.cs

@@ -290,24 +290,24 @@ public static System.Numerics.Complex Round(System.Numerics.Complex a)
 
         // The special functions, in double precision as the kernels define them.
         // https://github.com/asc-community/AngouriMath/issues/1607
-        public static System.Numerics.Complex Erf(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Erf(a);
-        public static double Erf(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Erf(a);
-        public static System.Numerics.Complex Erfc(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Erfc(a);
-        public static double Erfc(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Erfc(a);
-        public static System.Numerics.Complex Erfi(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Erfi(a);
-        public static double Erfi(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Erfi(a);
-        public static System.Numerics.Complex Ei(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Ei(a);
-        public static double Ei(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Ei(a);
-        public static System.Numerics.Complex Li(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Li(a);
-        public static double Li(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Li(a);
-        public static System.Numerics.Complex Si(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Si(a);
-        public static double Si(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Si(a);
-        public static System.Numerics.Complex Ci(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Ci(a);
-        public static double Ci(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Ci(a);
-        public static System.Numerics.Complex Shi(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Shi(a);
-        public static double Shi(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Shi(a);
-        public static System.Numerics.Complex Chi(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.Chi(a);
-        public static double Chi(double a) => AngouriMath.Core.Compilation.SpecialFunctions.Chi(a);
+        public static System.Numerics.Complex Erf(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Erf(a);
+        public static double Erf(double a) => AngouriMath.Numerics.SpecialFunctions.Erf(a);
+        public static System.Numerics.Complex Erfc(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Erfc(a);
+        public static double Erfc(double a) => AngouriMath.Numerics.SpecialFunctions.Erfc(a);
+        public static System.Numerics.Complex Erfi(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Erfi(a);
+        public static double Erfi(double a) => AngouriMath.Numerics.SpecialFunctions.Erfi(a);
+        public static System.Numerics.Complex Ei(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Ei(a);
+        public static double Ei(double a) => AngouriMath.Numerics.SpecialFunctions.Ei(a);
+        public static System.Numerics.Complex Li(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Li(a);
+        public static double Li(double a) => AngouriMath.Numerics.SpecialFunctions.Li(a);
+        public static System.Numerics.Complex Si(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Si(a);
+        public static double Si(double a) => AngouriMath.Numerics.SpecialFunctions.Si(a);
+        public static System.Numerics.Complex Ci(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Ci(a);
+        public static double Ci(double a) => AngouriMath.Numerics.SpecialFunctions.Ci(a);
+        public static System.Numerics.Complex Shi(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Shi(a);
+        public static double Shi(double a) => AngouriMath.Numerics.SpecialFunctions.Shi(a);
+        public static System.Numerics.Complex Chi(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.Chi(a);
+        public static double Chi(double a) => AngouriMath.Numerics.SpecialFunctions.Chi(a);
 
         /// <summary>
         /// True where <c>System.Numerics.Complex.IsNaN</c> is, spelled out because that overload is

Sources/AngouriMath/Functions/Compilation/IntoLinq/MathAllMethods.tt

@@ -194,8 +194,8 @@ namespace AngouriMath.Core.Compilation.IntoLinq
         // The special functions, in double precision as the kernels define them.
         // https://github.com/asc-community/AngouriMath/issues/1607
 <# foreach (var name in special) { #>
-        public static System.Numerics.Complex <#= name #>(System.Numerics.Complex a) => AngouriMath.Core.Compilation.SpecialFunctions.<#= name #>(a);
-        public static double <#= name #>(double a) => AngouriMath.Core.Compilation.SpecialFunctions.<#= name #>(a);
+        public static System.Numerics.Complex <#= name #>(System.Numerics.Complex a) => AngouriMath.Numerics.SpecialFunctions.<#= name #>(a);
+        public static double <#= name #>(double a) => AngouriMath.Numerics.SpecialFunctions.<#= name #>(a);
 <# } #>
 
         /// <summary>

…unctions/Compilation/SpecialFunctions.cs …AngouriMath/Numerics/SpecialFunctions.csSources/AngouriMath/Functions/Compilation/SpecialFunctions.cs renamed to Sources/AngouriMath/Numerics/SpecialFunctions.cs Sources/AngouriMath/Functions/Compilation/SpecialFunctions.cs renamed to Sources/AngouriMath/Numerics/SpecialFunctions.cs

@@ -8,11 +8,12 @@
 using System;
 using NumericsComplex = System.Numerics.Complex;
 
-namespace AngouriMath.Core.Compilation
+namespace AngouriMath.Numerics
 {
     /// <summary>
-    /// The special functions in double precision, for both compilers: <c>erf</c>, <c>erfc</c>,
-    /// <c>erfi</c>, <c>Ei</c>, <c>li</c>, <c>Si</c>, <c>Ci</c>, <c>Shi</c> and <c>Chi</c>.
+    /// The special functions in double precision: <c>erf</c>, <c>erfc</c>, <c>erfi</c>, <c>Ei</c>,
+    /// <c>li</c>, <c>Si</c>, <c>Ci</c>, <c>Shi</c> and <c>Chi</c>. Both compilers call them, and they
+    /// sit beside the numerical evaluation so that its fast tier can take them up too.
     /// The interpreter's kernels, <see cref="Entity.Number.Erf(Entity.Number.Complex)"/> and the
     /// others, work in arbitrary precision. At 20 digits they take 0.7 to 5.5 ms a call. Newton's
     /// method makes thousands of calls. These take a microsecond or two.
@@ -54,7 +55,7 @@ internal static class SpecialFunctions
 
         private static bool IsNaN(NumericsComplex z) => double.IsNaN(z.Real) || double.IsNaN(z.Imaginary);
         private static bool IsInfinite(NumericsComplex z) => double.IsInfinity(z.Real) || double.IsInfinity(z.Imaginary);
-        [ConstantField] private static readonly NumericsComplex NaN = new(double.NaN, double.NaN);
+        [AngouriMath.Core.ConstantField] private static readonly NumericsComplex NaN = new(double.NaN, double.NaN);
 
         public static NumericsComplex Erf(NumericsComplex z)
         {
@@ -140,15 +141,15 @@ private static NumericsComplex Faddeeva(NumericsComplex z)
         }
 
         private const int WeidemanTerms = 40;
-        [ConstantField] private static readonly double WeidemanL = Math.Sqrt(WeidemanTerms / Math.Sqrt(2));
+        [AngouriMath.Core.ConstantField] private static readonly double WeidemanL = Math.Sqrt(WeidemanTerms / Math.Sqrt(2));
 
         /// <summary>
         /// The polynomial's coefficients, <c>a_n = 1/(4N) sum_k f(t_k) cos(pi n k/(2N))</c> over
         /// <c>|k| &lt; 2N</c>, with <c>t_k = L tan(pi k/(4N))</c> and <c>f(t) = e^(-t^2) (L^2 + t^2)</c>:
         /// the discrete Fourier transform Weideman takes, written out, since <c>f</c> is even.
         /// Index 0 is unused.
         /// </summary>
-        [ConstantField] private static readonly double[] weideman = WeidemanCoefficients();
+        [AngouriMath.Core.ConstantField] private static readonly double[] weideman = WeidemanCoefficients();
 
         private static double[] WeidemanCoefficients()
         {