forked from tsai/mathnet-numerics
Christoph Ruegg
13 years ago
8 changed files with 603 additions and 3 deletions
@ -0,0 +1,116 @@ |
|||
(*** hide ***) |
|||
#I "../../out/lib/net40" |
|||
#r "MathNet.Numerics.dll" |
|||
#r "MathNet.Numerics.FSharp.dll" |
|||
|
|||
(** |
|||
Descriptive Statistics |
|||
====================== |
|||
|
|||
Univariate Statistical Analysis |
|||
------------------------------- |
|||
|
|||
To compute descriptive statistical characteristics of a sample set you can either call |
|||
the extension methods of the [Statistics][stats] class directly, or create a new |
|||
[DescriptiveStatistics][dstats] instance and pass your samples to its constructor to compute |
|||
all the characteristics in one pass. |
|||
|
|||
[stats]: http://numerics.mathdotnet.com/api/MathNet.Numerics.Statistics/Statistics.htm |
|||
[dstats]: http://numerics.mathdotnet.com/api/MathNet.Numerics.Statistics/DescriptiveStatistics.htm |
|||
|
|||
Code Sample using _DescriptiveStatistics_: |
|||
|
|||
[lang=csharp] |
|||
using MathNet.Numerics.Statistics; |
|||
|
|||
var samples = new ChiSquare(5).Samples().Take(1000); |
|||
var statistics = new DescriptiveStatistics(samples); |
|||
|
|||
// Order Statistics |
|||
var largestElement = statistics.Maximum; |
|||
var smallestElement = statistics.Minimum; |
|||
var median = statistics.Median; |
|||
|
|||
// Central Tendency |
|||
var mean = statistics.Mean; |
|||
|
|||
// Dispersion |
|||
var variance = statistics.Variance; |
|||
var stdDev = statistics.StandardDeviation; |
|||
|
|||
// Other Statistics |
|||
var kurtosis = statistics.Kurtosis; |
|||
var skewness = statistics.Skewness; |
|||
|
|||
Code Sample using the extensions methods: |
|||
|
|||
[lang=csharp] |
|||
using MathNet.Numerics.Statistics; |
|||
|
|||
// Extension methods are defined on IEnumerable<double>, |
|||
// yet we call ToArray so all the methods operate on the same data |
|||
var samples = new ChiSquare(5).Samples().Take(1000).ToArray(); |
|||
|
|||
// Order Statistics |
|||
var largestElement = samples.Maximum(); |
|||
var smallestElement = samples.Minimum(); |
|||
var median = samples.Median(); |
|||
var 250thOrderStatistic = samples.OrderStatistic(250); |
|||
|
|||
// Central Tendency |
|||
var mean = samples.Mean(); |
|||
|
|||
// Dispersion |
|||
var variance = samples.Variance(); |
|||
var biasedPopulationVariance = samples.PopulationVariance(); |
|||
var stdDev = samples.StandardDeviation(); |
|||
var biasedPopulationStdDev = samples.PopulationStandardDeviation(); |
|||
|
|||
|
|||
Histograms |
|||
---------- |
|||
|
|||
A histrogram can be computed using the [Histogram][hist] class. Its constructor takes |
|||
the samples enumerable. the number of buckets to create, plus optionally the range |
|||
(minimum, maximum) of the sample data if available. |
|||
|
|||
[hist]: http://numerics.mathdotnet.com/api/MathNet.Numerics.Statistics/Histogram.htm |
|||
|
|||
[lang=csharp] |
|||
var histogram = new Histogram(samples, 10); |
|||
var bucket3count = histogram[2].Count; |
|||
|
|||
|
|||
Percentiles |
|||
----------- |
|||
|
|||
Percentiles can be computed using the [Percentile][percentile] class. |
|||
It supports four methods, which can be chosen using the _Methods_ property: |
|||
|
|||
[percentile]: http://numerics.mathdotnet.com/api/MathNet.Numerics.Statistics/Percentile.htm |
|||
|
|||
* _Nist_: Using the method [recommended](http://www.itl.nist.gov/div898/handbook/prc/section2/prc252.htm) by NIST. This is the default method. |
|||
* _Nearest_: Using the [nearest rank](http://en.wikipedia.org/wiki/Percentile#Nearest_Rank) method. |
|||
* _Excel_: Using the [method](http://www.itl.nist.gov/div898/handbook/prc/section2/prc252.htm) that is also used by Microsoft Excel. |
|||
* _Interpolation_: Using linear interpolation between the two nearest ranks, see [wikipedia](http://en.wikipedia.org/wiki/Percentile#Linear_Interpolation_Between_Closest_Ranks). |
|||
|
|||
[lang=csharp] |
|||
var percentile = new Percentile(samples) { Method = PercentileMethod.Nearest }; |
|||
var percentile90 = percentile.Compute(0.9); |
|||
var percentiles = percentile.Compute(new[] { .25, .5, .75 }); |
|||
|
|||
|
|||
Correlation |
|||
----------- |
|||
|
|||
The [Correlation][corr] class supports computing Pearson product-momentum correlation coefficients: |
|||
|
|||
[corr]: http://numerics.mathdotnet.com/api/MathNet.Numerics.Statistics/Correlation.htm |
|||
|
|||
Code Sample: Computing the correlation coefficient between 1000 samples of f(x) = 2x and g(x) = x^2: |
|||
|
|||
[lang=csharp] |
|||
double[] dataF = SignalGenerator.EquidistantInterval(x => x * 2, 0, 100, 1000); |
|||
double[] dataG = SignalGenerator.EquidistantInterval(x => x * x, 0, 100, 1000); |
|||
double correlation = Correlation.Pearson(dataF, dataG); |
|||
*) |
|||
@ -0,0 +1,316 @@ |
|||
(*** hide ***) |
|||
#I "../../out/lib/net40" |
|||
#r "MathNet.Numerics.dll" |
|||
#r "MathNet.Numerics.FSharp.dll" |
|||
|
|||
(** |
|||
Special Functions |
|||
================= |
|||
|
|||
Factorial |
|||
--------- |
|||
|
|||
`Factorial(x)` |
|||
|
|||
$$$ |
|||
x \mapsto x! = \prod_{k=1}^{x} k = \Gamma(x+1) |
|||
|
|||
`FactorialLn(x)` |
|||
|
|||
$$$ |
|||
x \mapsto \ln x! = \ln\Gamma(x+1) |
|||
|
|||
`Binomial(n,k)` |
|||
Binomial Coefficient |
|||
|
|||
$$$ |
|||
\binom{n}{k} = \mathrm{C}_n^k = \frac{n!}{k! (n-k)!} |
|||
|
|||
`BinomialLn(n,k)` |
|||
|
|||
$$$ |
|||
\ln \binom{n}{k} = \ln n! - \ln k! - \ln(n-k)! |
|||
|
|||
`Multinomial(n,k[])` |
|||
Multinomial Coefficient |
|||
|
|||
$$$ |
|||
\binom{n}{k_1,k_2,\dots,k_r} = \frac{n!}{k_1! k_2! \cdots k_r!} = \frac{n!}{\prod_{i=1}^{r}k_i!} |
|||
|
|||
Code Sample: |
|||
|
|||
[lang=csharp] |
|||
double x = SpecialFunctions.Factorial(14); // 87178291200.0 |
|||
double y = SpecialFunctions.Factorial(31); // 8.2228386541779224E+33 |
|||
|
|||
|
|||
Gamma-related functions |
|||
----------------------- |
|||
|
|||
#### Gamma |
|||
`SpecialFunctions.Gamma(a)` |
|||
|
|||
$$$ |
|||
\Gamma(a) = \int_0^\infty t^{a-1} e^{-t}\,\mathrm{d}t |
|||
|
|||
`SpecialFunctions.GammaLn(a)` |
|||
|
|||
$$$ |
|||
\ln\Gamma(a) |
|||
|
|||
|
|||
#### Incomplete Gamma |
|||
`SpecialFunctions.GammaLowerIncomplete(a,x)` |
|||
Lower incomplete Gamma function (unregularized). |
|||
|
|||
$$$ |
|||
\gamma(a,x) = \int_0^x t^{a-1} e^{-t}\,\mathrm{d}t |
|||
|
|||
`SpecialFunctions.GammaUpperIncomplete(a,x)` |
|||
Upper incomplete Gamma function (unregularized). |
|||
|
|||
$$$ |
|||
\Gamma(a,x) = \int_x^\infty t^{a-1} e^{-t}\,\mathrm{d}t |
|||
|
|||
|
|||
#### Regularized Gamma |
|||
`SpecialFunctions.GammaLowerRegularized(a,x)` |
|||
Lower regularized incomplete Gamma function. |
|||
|
|||
$$$ |
|||
\mathrm{P}(a,x) = \frac{\gamma(a,x)}{\Gamma(a)} |
|||
|
|||
`SpecialFunctions.GammaUpperRegularized(a,x)` |
|||
Upper regularized incomplete Gamma function. |
|||
|
|||
$$$ |
|||
\mathrm{Q}(a,x) = \frac{\Gamma(a,x)}{\Gamma(a)} |
|||
|
|||
`SpecialFunctions.GammaLowerRegularizedInv(a, y)` |
|||
Inverse $x$ of the lower regularized Gamma function, such that $\mathrm{P}(a,x) = y$. |
|||
|
|||
$$$ |
|||
\mathrm{P}^{-1}(a,y) |
|||
|
|||
|
|||
#### Psi: Derivative of Logarithmic Gamma |
|||
`SpecialFunctions.DiGamma(x)` |
|||
|
|||
$$$ |
|||
\psi(x) = \frac{\mathrm{d}}{\mathrm{d}x}\ln\Gamma(x) |
|||
|
|||
`SpecialFunctions.DiGammaInv(p)` |
|||
Inverse $x$ of the DiGamma function, such that $\psi(x) = p$. |
|||
|
|||
$$$ |
|||
\psi^{-1}(p) |
|||
|
|||
|
|||
Euler Beta-related functions |
|||
---------------------------- |
|||
|
|||
#### Euler Beta |
|||
`SpecialFunctions.Beta(a,b)` |
|||
|
|||
$$$ |
|||
\mathrm{B}(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1}\,\mathrm{d}t = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)} |
|||
|
|||
`SpecialFunctions.BetaLn(a,b)` |
|||
|
|||
$$$ |
|||
\ln\mathrm{B}(a,b) = \Gamma(a) + \Gamma(b) - \Gamma(a+b) |
|||
|
|||
|
|||
#### Incomplete Beta |
|||
`SpecialFunctions.BetaIncomplete(a,b,x)` |
|||
Lower incomplete Beta function (unregularized). |
|||
|
|||
$$$ |
|||
\mathrm{B}_x(a,b) = \int_0^x t^{a-1} (1-t)^{b-1}\,\mathrm{d}t |
|||
|
|||
|
|||
#### Regularized Beta |
|||
`SpecialFunctions.BetaRegularized(a,b,x)` |
|||
Lower incomplete regularized Beta function. |
|||
|
|||
$$$ |
|||
\mathrm{I}_x(a,b) = \frac{\mathrm{B}(a,b,x)}{\mathrm{B}(a,b)} |
|||
|
|||
|
|||
Error functions |
|||
--------------- |
|||
|
|||
#### Error Function |
|||
`SpecialFunctions.Erf(x)` |
|||
|
|||
$$$ |
|||
\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}}\int_0^x e^{-t^2}\,\mathrm{d}t |
|||
|
|||
`SpecialFunctions.ErfInv(z)` |
|||
Inverse $x$ of the Error function, such that $\mathrm{erf}(x) = z$. |
|||
|
|||
$$$ |
|||
z \mapsto \mathrm{erf}^{-1}(z) |
|||
|
|||
|
|||
#### Complementary Error function. |
|||
`SpecialFunctions.Erfc(x)` |
|||
|
|||
$$$ |
|||
\mathrm{erfc}(x) = 1-\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}}\int_x^\infty e^{-t^2}\,\mathrm{d}t |
|||
|
|||
`SpecialFunctions.ErfcInv(z)` |
|||
Inverse $x$ of the complementary Error function, such that $\mathrm{erfc}(x) = z$. |
|||
|
|||
$$$ |
|||
z \mapsto \mathrm{erfc}^{-1}(z) |
|||
|
|||
Code Sample: |
|||
|
|||
[lang=csharp] |
|||
double erf = SpecialFunctions.Erf(0.9); // 0.7969082124 |
|||
|
|||
|
|||
Sigmoid: Logistic function |
|||
-------------------------- |
|||
|
|||
`SpecialFunctions.Logistic(x)` |
|||
|
|||
$$$ |
|||
x \mapsto \frac{1}{1+e^{-x}} |
|||
|
|||
`SpecialFunctions.Logit(y)` |
|||
Inverse of the Logistic function, for $y$ between 0 and 1 (where the function is real-valued). |
|||
|
|||
$$$ |
|||
y \mapsto \ln \frac{y}{1-y} |
|||
|
|||
|
|||
Harmonic Numbers |
|||
---------------- |
|||
|
|||
`SpecialFunctions.Harmonic(t)` |
|||
The n-th Harmonic number is the sum of the reciprocals of the first n natural numbers. |
|||
With $\gamma$ as the Euler-Mascheroni constant and the DiGamma function: |
|||
|
|||
$$$ |
|||
\mathrm{H}_n = \sum_{k=1}^{n}\frac{1}{k} = \gamma - \psi(n+1) |
|||
|
|||
`SpecialFunctions.GeneralHarmonic(n, m)` |
|||
Generalized harmonic number of order n of m. |
|||
|
|||
$$$ |
|||
\mathrm{H}_{n,m} = \sum_{k=1}^{n}\frac{1}{k^m} |
|||
|
|||
|
|||
Bessel and Struve Functions |
|||
--------------------------- |
|||
|
|||
#### Modified Bessel functions |
|||
|
|||
Bessel functions are canonical solutions $y(x)$ of Bessel's differential equation |
|||
|
|||
$$$ |
|||
x^2\frac{\mathrm{d}^2y}{\mathrm{d}x^2}+x\frac{\mathrm{d}y}{\mathrm{d}x}+(x^2-\alpha^2)y = 0 |
|||
|
|||
Modified Bessel functions: |
|||
|
|||
$$$ |
|||
\begin{align} |
|||
\mathrm{I}_\alpha(x) &= \imath^{-\alpha}\mathrm{J}_\alpha(\imath x) = \sum_{m=0}^\infty \frac{1}{m!\Gamma(m+\alpha+1)}\left(\frac{x}{2}\right)^{2m+\alpha} \\ |
|||
\mathrm{K}_\alpha(x) &= \frac{\pi}{2} \frac{\mathrm{I}_{-\alpha}(x)-\mathrm{I}_\alpha(x)}{\sin(\alpha\pi)} |
|||
\end{align} |
|||
|
|||
`SpecialFunctions.BesselI0(x)` |
|||
Modified or hyperbolic Bessel function of the first kind, order 0. |
|||
|
|||
$$$ |
|||
x \mapsto \mathrm{I}_0(x) |
|||
|
|||
`SpecialFunctions.BesselI1(x)` |
|||
Modified or hyperbolic Bessel function of the first kind, order 1. |
|||
|
|||
$$$ |
|||
x \mapsto \mathrm{I}_1(x) |
|||
|
|||
`SpecialFunctions.BesselK0(x)` |
|||
Modified or hyperbolic Bessel function of the second kind, order 0. |
|||
|
|||
$$$ |
|||
x \mapsto \mathrm{K}_0(x) |
|||
|
|||
`SpecialFunctions.BesselK0e(x)` |
|||
Exponentionally scaled modified Bessel function of the second kind, order 0. |
|||
|
|||
$$$ |
|||
x \mapsto e^x\mathrm{K}_0(x) |
|||
|
|||
`SpecialFunctions.BesselK1(x)` |
|||
Modified or hyperbolic Bessel function of the second kind, order 1. |
|||
|
|||
$$$ |
|||
x \mapsto \mathrm{K}_1(x) |
|||
|
|||
`SpecialFunctions.BesselK1e(x)` |
|||
Exponentionally scaled modified Bessel function of the second kind, order 1. |
|||
|
|||
$$$ |
|||
x \mapsto e^x\mathrm{K}_1(x) |
|||
|
|||
|
|||
#### Modified Struve functions |
|||
|
|||
Struve functions are solutions $y(x)$ of the non-homogenous Bessel's differential equation |
|||
|
|||
$$$ |
|||
x^2\frac{\mathrm{d}^2y}{\mathrm{d}x^2}+x\frac{\mathrm{d}y}{\mathrm{d}x}+(x^2-\alpha^2)y = \frac{4(\frac{x}{2})^{\alpha+1}}{\sqrt{\pi}\Gamma(\alpha+\frac{1}{2})} |
|||
|
|||
Modified Struve functions: |
|||
|
|||
$$$ |
|||
\mathrm{L}_\alpha(x) = \left(\frac{x}{2}\right)^{\alpha+1}\sum_{k=0}^\infty \frac{1}{\Gamma(\frac{3}{2}+k)\Gamma(\frac{3}{2}+k+\alpha)}\left(\frac{x}{2}\right)^{2k} |
|||
|
|||
`SpecialFunctions.StruveL0(x)` |
|||
Modified Struve function of order 0. |
|||
|
|||
$$$ |
|||
x \mapsto \mathrm{L}_0(x) |
|||
|
|||
`SpecialFunctions.StruveL1(x)` |
|||
Modified Struve function of order 1. |
|||
|
|||
$$$ |
|||
x \mapsto \mathrm{L}_1(x) |
|||
|
|||
|
|||
#### Misc |
|||
|
|||
`SpecialFunctions.BesselI0MStruveL0(x)` |
|||
Difference between the Bessel $I_0$ and the Struve $L_0$ functions. |
|||
|
|||
$$$ |
|||
x \mapsto I_0(x) - L_0(x) |
|||
|
|||
`SpecialFunctions.BesselI1MStruveL1(x)` |
|||
Difference between the Bessel $I_1$ and the Struve $L_1$ functions. |
|||
|
|||
$$$ |
|||
x \mapsto I_1(x) - L_1(x) |
|||
|
|||
|
|||
Numeric Stability |
|||
----------------- |
|||
|
|||
`SpecialFunctions.ExponentialMinusOne(power)` |
|||
$\exp x-1$ is a typical case where a subtraction can lead to low accuracy. |
|||
For example, at $10^{-13}$ the naive expression is 0.08% off, at $10^{-15}$ roughly 11% and at $10^{-18}$ it just returns 0. |
|||
|
|||
$$$ |
|||
x \mapsto e^x - 1 |
|||
|
|||
`SpecialFunctions.Hypotenuse(a, b)` |
|||
|
|||
$$$ |
|||
(a,b) \mapsto \sqrt{a^2 + b^2} |
|||
|
|||
*) |
|||
@ -0,0 +1,69 @@ |
|||
(*** hide ***) |
|||
#I "../../out/lib/net40" |
|||
#r "MathNet.Numerics.dll" |
|||
#r "MathNet.Numerics.FSharp.dll" |
|||
|
|||
(** |
|||
Fourier and related linear integral transforms |
|||
============================================== |
|||
|
|||
Math.NET Numerics currently supports two linear integral transforms: The discrete Fourier |
|||
transform and the discrete Hartley transform. Both are strongly localized in the frequency |
|||
spectrum, but while the Fourier transform operates on complex values, the Hartley transform |
|||
operates on real values only. |
|||
|
|||
The transforms implement a separate forward and inverse transform method. |
|||
How the forward and inverse methods are related to each other and what exact definition |
|||
is to be used can be specified by an additional _options_ parameter. |
|||
|
|||
Fourier Space: Discrete Fourier Transform and FFT |
|||
------------------------------------------------- |
|||
|
|||
Wikipedia has an extensive [article on the discrete fourier transform (DFT)](http://en.wikipedia.org/wiki/Discrete_Fourier_transform). |
|||
We provide implementations of the following algorithms: |
|||
|
|||
* *Naive Discrete Fourier Transform (DFT):* Out-place transform for arbitrary vector lengths. Mainly intended for verifying faster algorithms: _[NaiveForward](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms.Algorithms/DiscreteFourierTransform.htm#NaiveForward)_, _[NaiveInverse](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms.Algorithms/DiscreteFourierTransform.htm#NaiveInverse)_ |
|||
|
|||
* *Radix-2 Fast Fourier Transform (FFT):* In-place fast fourier transform for vectors with a power-of-two length (Radix-2): _[Radix2Forward](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms.Algorithms/DiscreteFourierTransform.htm#Radix2Forward)_, _[url:Radix2Inverse](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms.Algorithms/DiscreteFourierTransform.htm#Radix2Inverse)_ |
|||
|
|||
* *Bluestein Fast Fourier Transform (FFT):* In-place fast fourier transform for arbitrary vector lengths: _[BluesteinForward](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms.Algorithms/DiscreteFourierTransform.htm#BluesteinForward)_, _[url:BluesteinInverse](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms.Algorithms/DiscreteFourierTransform.htm#BluesteinInverse)_ |
|||
|
|||
Furthermore, the _[Transform](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms/Transform.htm)_ class provides a shortcut for the Bluestein FFT using static methods which are even easier to use: _[FourierForward](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms/Transform.htm#FourierForward)_, _[FourierInverse](http://api.mathdotnet.com/Numerics/MathNet.Numerics.IntegralTransforms/Transform.htm#FourierInverse)_. |
|||
|
|||
Code Sample using the Transform class: |
|||
|
|||
[lang=csharp] |
|||
// create a complex sample vector of length 96 |
|||
Complex[] samples = SignalGenerator.EquidistantInterval( |
|||
t => new Complex(1.0 / (t * t + 1.0), t / (t * t + 1.0)), |
|||
-16, 16, 96); |
|||
|
|||
// inplace bluestein FFT with default options |
|||
Transform.FourierForward(samples); |
|||
|
|||
Fourier Options: |
|||
|
|||
* *Default:* Uses a negative exponent sign in forward transformations, and symmetric scaling (that is, sqrt(1/N) for both forward and inverse transformation). This is the convention used in Maple and is widely accepted in the educational sector (due to the symmetry). |
|||
* *AsymmetricScaling:* Set this flag to suppress scaling on the forward transformation but scale the inverse transform with 1/N. |
|||
* *NoScaling:* Set this flag to suppress scaling for both forward and inverse transformation. Note that in this case if you apply first the forward and then inverse transformation you won't get back the original signal (by factor N/2). |
|||
* *InverseExponent:* Uses the positive instead of the negative sign in the forward exponent, and the negative (instead of positive) exponent in the inverse transformation. |
|||
* *Matlab:* Use this flag if you need Matlab compatibility. Equals to setting the _AsymmetricScaling_ flag. This matches the definition used in the [url:wikipedia article|http://en.wikipedia.org/wiki/Discrete_Fourier_transform]. |
|||
* *NumericalRecipes:* Use this flag if you need Numerical Recipes compatibility. Equal to setting both the _InverseExponent_ and the _NoScaling_ flags. |
|||
|
|||
Useful symmetries of the fourier transform: |
|||
|
|||
* h(t) is real valued <=> real part of H(f) is even, imgainary part of H(f) is odd |
|||
* h(t) is imaginary valued <=> real part of H(f) is odd, imaginary part of H(f) is even |
|||
* h(t) is even <=> H(f) is even |
|||
* h(t) is odd <=> H(f) is odd |
|||
* h(t) is real-valued even <=> H(f) is real-valued even |
|||
* h(t) is real-valued odd <=> H(f) is imaginary-valued odd |
|||
* h(t) is imaginary-valued even <=> H(f) is imaginary-valued even |
|||
* h(t) is imaginary-valued odd <=> H(f) is real-valued odd |
|||
|
|||
Hartley Space: Discrete Hartley Transform |
|||
----------------------------------------- |
|||
|
|||
... |
|||
|
|||
*) |
|||
@ -0,0 +1,19 @@ |
|||
(*** hide ***) |
|||
#I "../../out/lib/net40" |
|||
#r "MathNet.Numerics.dll" |
|||
#r "MathNet.Numerics.FSharp.dll" |
|||
|
|||
(** |
|||
Numerical Integration |
|||
===================== |
|||
|
|||
Simpson's Rule |
|||
-------------- |
|||
|
|||
Newton Cotes Trapezium Rule |
|||
--------------------------- |
|||
|
|||
Double-Exponential Transformation |
|||
--------------------------------- |
|||
|
|||
*) |
|||
@ -0,0 +1,50 @@ |
|||
(*** hide ***) |
|||
#I "../../out/lib/net40" |
|||
#r "MathNet.Numerics.dll" |
|||
#r "MathNet.Numerics.FSharp.dll" |
|||
|
|||
(** |
|||
Interpolation |
|||
============= |
|||
|
|||
Namespace: MathNet.Numerics.Interpolation |
|||
|
|||
Interpolation is a two-phased operation in Math.NET Numerics: |
|||
|
|||
1. Create an interpolation scheme for the chosen algorithm and optimized for the given sample points. You get back a class that implements the _IInterpolation_ interface. |
|||
2. Use this scheme to compute values at arbitrary points. Some interpolation algorithms also allow you to compute the derivative and the indefinite integral at that point. |
|||
|
|||
The static `Interpolate` class provides simple factory methods to create the interpolation scheme in a simple method call: |
|||
|
|||
* _RationalWithoutPoles_, creates a Floater-Hormann barycentric interpolation |
|||
* _RationalWithPoles_, creates a Bulirsch & Stoer rational interpolation |
|||
* _LinearBetweenPoints_, creates a linear spline interpolation |
|||
|
|||
If unsure, we recommend using _RationalWithoutPoles_ for most cases. |
|||
|
|||
Alternatively you can also use the algorithms directly, they're publicly available in the _Algorithms_ sub-namespace for those who want to use a specific algorithm. The following algorithms are available: |
|||
|
|||
Interpolation on equidistant sample points |
|||
------------------------------------------ |
|||
|
|||
* *Polynomial*: Barycentric Algorithm |
|||
|
|||
Interpolation on arbitrary sample points |
|||
---------------------------------------- |
|||
|
|||
* *Rational pole-free*: Barycentric Floater-Hormann Algorithm |
|||
* **Rational with poles**: Bulirsch & Stoer Algorithm |
|||
* *Neville Polynomial*: Neville Algorithm. Note that the Neville algorithm performs very badly on equidistant points. If you need to interpolate a polynomial on equidistant points, we recommend to use the barycentric algorithm instead. |
|||
* *Linear Spline* |
|||
* *Cubic Spline* with boundary conditions |
|||
* *Natural Cubic Spline* |
|||
* *Akima Cubic Spline* |
|||
|
|||
Interpolation with additional data |
|||
---------------------------------- |
|||
|
|||
* *Generic Barycentric Interpolation*, requires barycentric weights |
|||
* *Generic Spline*, requires spline coefficients |
|||
* *Generic Cubic Hermite Spline*, requires the derivatives |
|||
|
|||
*) |
|||
Loading…
Reference in new issue