<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<preclass="fssnip highlighted"><codelang="fsharp"><spanclass="pn">.</span><spanclass="o">/</span><spanclass="id">build</span><spanclass="pn">.</span><spanclass="id">sh</span><spanclass="id">MklWinBuild</span><spanclass="c">// build both 32 and 64 bit variants</span>
<spanclass="l">2: </span>
<spanclass="pn">.</span><spanclass="o">/</span><spanclass="id">build</span><spanclass="pn">.</span><spanclass="id">sh</span><spanclass="id">MklTest</span><spanclass="c">// run all tests with the MKL provider enforced</span>
<spanclass="l">3: </span>
<spanclass="pn">.</span><spanclass="o">/</span><spanclass="id">build</span><spanclass="pn">.</span><spanclass="id">sh</span><spanclass="id">MklWinAll</span><spanclass="c">// build and run tests</span>
</pre></td>
</code></pre>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="fsharp"><spanclass="o">.</span><spanclass="o">/</span><spanclass="i">build</span><spanclass="o">.</span><spanclass="i">sh</span><spanclass="i">MklWinBuild</span><spanclass="c">// build both 32 and 64 bit variants</span>
<spanclass="o">.</span><spanclass="o">/</span><spanclass="i">build</span><spanclass="o">.</span><spanclass="i">sh</span><spanclass="i">MklTest</span><spanclass="c">// run all tests with the MKL provider enforced</span>
<spanclass="o">.</span><spanclass="o">/</span><spanclass="i">build</span><spanclass="o">.</span><spanclass="i">sh</span><spanclass="i">MklWinAll</span><spanclass="c">// build and run tests</span>
</code></pre></td>
</tr>
</table>
<p>If you run into an error with <code>mkl_link_tool.exe</code> you may need to patch a targets file,
<p>If you run into an error with <code>mkl_link_tool.exe</code> you may need to patch a targets file,
see <ahref="https://software.intel.com/en-us/forums/intel-math-kernel-library/topic/851578">MKL 2020.1, VS2019 linking bug </a>.</p>
see <ahref="https://software.intel.com/en-us/forums/intel-math-kernel-library/topic/851578">MKL 2020.1, VS2019 linking bug </a>.</p>
<p>The build puts the binaries to <code>out/MKL/Windows/x64</code> (and <code>x86</code>), the NuGet package
<p>The build puts the binaries to <code>out/MKL/Windows/x64</code> (and <code>x86</code>), the NuGet package
@ -240,30 +267,18 @@ this is also what the unit tests do when you run the <code>MklTest</code> build
<li><p>Consider a tweet via <ahref="https://twitter.com/MathDotNet">@MathDotNet</a></p></li>
<li><p>Consider a tweet via <ahref="https://twitter.com/MathDotNet">@MathDotNet</a></p></li>
<li>
<li>
@ -273,90 +288,21 @@ this is also what the unit tests do when you run the <code>MklTest</code> build
</li>
</li>
</ul>
</ul>
<divclass="tip"id="fs1">type unit = Unit<br/><br/>Full name: Microsoft.FSharp.Core.unit</div>
<divclass="fsdocs-tip"id="fs1">type unit = Unit<br/><em><summary>The type 'unit', which has only one value "()". This value is special and
always uses the representation 'null'.</summary><br/><category index="1">Basic Types</category></em></div>
<divclass="fsdocs-tip"id="fs2">val using : resource:'T -> action:('T ->'U) ->'U (requires 'T :> System.IDisposable)<br/><em><summary>Clean up resources associated with the input object after the completion of the given function.
Cleanup occurs even when an exception is raised by the protected
code. </summary><br/><param name="resource">The resource to be disposed after action is called.</param><br/><param name="action">The action that accepts the resource.</param><br/><returns>The resulting value.</returns></em></div>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<h1><aname="Contribute-to-Math-NET-Numerics"class="anchor"href="#Contribute-to-Math-NET-Numerics">Contribute to Math.NET Numerics</a></h1>
<p>Math.NET Numerics is driven by the community and contributors like you. I'm excited that you're interested to help us move forward and improve Numerics. We usually accept contributions and try to attribute them properly, provided they keep the library consistent, focused and mathematically accurate. Have a look at the following tips to get started quickly. I'm looking forward to your pull requests! Thanks!</p>
<p>Math.NET Numerics is driven by the community and contributors like you. I'm excited that you're interested to help us move forward and improve Numerics. We usually accept contributions and try to attribute them properly, provided they keep the library consistent, focused and mathematically accurate. Have a look at the following tips to get started quickly. I'm looking forward to your pull requests! Thanks!</p>
@ -95,87 +170,15 @@ We try to follow <a href="https://semver.org/">semantic versioning</a>, meaning
Please avoid merging mainline back into your pull request branch. If you need to leverage some changes recently added to mainline, consider to rebase instead. In other words, please make sure your commits sit directly on top of a recent mainline master.</p>
Please avoid merging mainline back into your pull request branch. If you need to leverage some changes recently added to mainline, consider to rebase instead. In other words, please make sure your commits sit directly on top of a recent mainline master.</p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<p>The Math.NET project is a community effort. We accept contributions and pull requests, but other support like submitting issues or helping the community are just as valuable. Why don't you join us as well?</p>
<p>The Math.NET project is a community effort. We accept contributions and pull requests, but other support like submitting issues or helping the community are just as valuable. Why don't you join us as well?</p>
<p><strong>Thanks for all the contributions!</strong></p>
<p><strong>Thanks for all the contributions!</strong></p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<spanclass="fsi">val it : float = -4.133520783e-17</span>
<spanclass="fsi">val it : float = -4.133520783e-17</span>
</code></pre></td>
</code></pre>
</tr>
</table>
<h2><aname="Variance-and-Standard-Deviation"class="anchor"href="#Variance-and-Standard-Deviation">Variance and Standard Deviation</a></h2>
<h2><aname="Variance-and-Standard-Deviation"class="anchor"href="#Variance-and-Standard-Deviation">Variance and Standard Deviation</a></h2>
<p>Variance <spanclass="math">\(\sigma^2\)</span> and the Standard Deviation <spanclass="math">\(\sigma\)</span> are measures of how far the samples are spread out.</p>
<p>Variance <spanclass="math">\(\sigma^2\)</span> and the Standard Deviation <spanclass="math">\(\sigma\)</span> are measures of how far the samples are spread out.</p>
<p>If the whole population is available, the functions with the Population-prefix
<p>If the whole population is available, the functions with the Population-prefix
@ -172,38 +216,23 @@ Bessel's correction with an <span class="math">\(N-1\)</span> normalizer to a sa
<spanclass="fsi">val it : float = 13.97580653</span>
<spanclass="fsi">val it : float = 13.97580653</span>
</code></pre></td>
</code></pre>
</tr>
</table>
<h4><aname="Quantile-Conventions-and-Compatibility"class="anchor"href="#Quantile-Conventions-and-Compatibility">Quantile Conventions and Compatibility</a></h4>
<h4><aname="Quantile-Conventions-and-Compatibility"class="anchor"href="#Quantile-Conventions-and-Compatibility">Quantile Conventions and Compatibility</a></h4>
<p>Remember that all these descriptive statistics do not <em>compute</em> but merely <em>estimate</em>
<p>Remember that all these descriptive statistics do not <em>compute</em> but merely <em>estimate</em>
statistical indicators of the value distribution. In the case of quantiles,
statistical indicators of the value distribution. In the case of quantiles,
@ -440,22 +409,13 @@ Similar to <code>QuantileDefinition</code>, the <code>RankDefinition</code> enum
<p>Counterpart of the <code>Quantile</code> function, estimates <spanclass="math">\(\tau\)</span> of the provided <spanclass="math">\(\tau\)</span>-quantile value
<p>Counterpart of the <code>Quantile</code> function, estimates <spanclass="math">\(\tau\)</span> of the provided <spanclass="math">\(\tau\)</span>-quantile value
<spanclass="math">\(x\)</span> from the provided samples. The <spanclass="math">\(\tau\)</span>-quantile is the data value where the cumulative distribution
<spanclass="math">\(x\)</span> from the provided samples. The <spanclass="math">\(\tau\)</span>-quantile is the data value where the cumulative distribution
@ -463,165 +423,63 @@ function crosses <span class="math">\(\tau\)</span>.</p>
<p>A histogram can be computed using the <ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.Statistics/Histogram.htm">Histogram</a> class. Its constructor takes
<p>A histogram can be computed using the <ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.Statistics/Histogram.htm">Histogram</a> class. Its constructor takes
the samples enumerable, the number of buckets to create, plus optionally the range
the samples enumerable, the number of buckets to create, plus optionally the range
(minimum, maximum) of the sample data if available.</p>
(minimum, maximum) of the sample data if available.</p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<p>A metric or distance function is a function <spanclass="math">\(d(x,y)\)</span> that defines the distance
<p>A metric or distance function is a function <spanclass="math">\(d(x,y)\)</span> that defines the distance
between elements of a set as a non-negative real number. If the distance is zero, both elements are equivalent
between elements of a set as a non-negative real number. If the distance is zero, both elements are equivalent
under that specific metric. Distance functions thus provide a way to measure how close two elements are, where elements
under that specific metric. Distance functions thus provide a way to measure how close two elements are, where elements
@ -68,196 +143,100 @@ as error or cost functions to be minimized in an optimization problem.</p>
are valid metrics as well. Every normed vector space induces a distance given by <spanclass="math">\(d(\vec x, \vec y) = \|\vec x - \vec y\|\)</span>.</p>
are valid metrics as well. Every normed vector space induces a distance given by <spanclass="math">\(d(\vec x, \vec y) = \|\vec x - \vec y\|\)</span>.</p>
<p>Math.NET Numerics provides the following distance functions on vectors and arrays:</p>
<p>Math.NET Numerics provides the following distance functions on vectors and arrays:</p>
<h2><aname="Sum-of-Absolute-Difference-SAD"class="anchor"href="#Sum-of-Absolute-Difference-SAD">Sum of Absolute Difference (SAD)</a></h2>
<h2><aname="Sum-of-Absolute-Difference-SAD"class="anchor"href="#Sum-of-Absolute-Difference-SAD">Sum of Absolute Difference (SAD)</a></h2>
<p>The sum of absolute difference is equivalent to the <spanclass="math">\(L_1\)</span>-norm of the difference, also known as Manhattan- or Taxicab-norm.
<p>The sum of absolute difference is equivalent to the <spanclass="math">\(L_1\)</span>-norm of the difference, also known as Manhattan- or Taxicab-norm.
The <code>abs</code> function makes this metric a bit complicated to deal with analytically, but it is more robust than SSD.</p>
The <code>abs</code> function makes this metric a bit complicated to deal with analytically, but it is more robust than SSD.</p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
Generate.LinearRangeMap(<spanclass="n">10</span>, <spanclass="n">2</span>, <spanclass="n">15</span>, Math.Sin); <spanclass="c">// applies sin(x) to each value</span>
Generate.LinearRangeMap(<spanclass="n">10</span>, <spanclass="n">2</span>, <spanclass="n">15</span>, Math.Sin); <spanclass="c">// applies sin(x) to each value</span>
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>Most of the routines in the <code>Generate</code> class have variants with a <code>Map</code> suffix.
<p>Most of the routines in the <code>Generate</code> class have variants with a <code>Map</code> suffix.
@ -98,32 +163,19 @@ lazy enumerable sequences instead of arrays.</p>
<p>Generates a linearly or log-spaced array within an interval, but other than linear range
<p>Generates a linearly or log-spaced array within an interval, but other than linear range
where the step is provided, here we instead provide the number of values we want.
where the step is provided, here we instead provide the number of values we want.
This is equivalent to the linspace and logspace operators in MATLAB.</p>
This is equivalent to the linspace and logspace operators in MATLAB.</p>
Generate.LinearSpacedMap(<spanclass="n">15</span>, <spanclass="n">0.0</span>, Math.Pi, Math.Sin); <spanclass="c">// applies sin(x) to each value</span>
Generate.LinearSpacedMap(<spanclass="n">15</span>, <spanclass="n">0.0</span>, Math.Pi, Math.Sin); <spanclass="c">// applies sin(x) to each value</span>
<p><code>LogSpaced</code> works the same way but instead of the values <spanclass="math">\(10^x\)</span> it spaces the decade exponents <spanclass="math">\(x\)</span> linearly
<p><code>LogSpaced</code> works the same way but instead of the values <spanclass="math">\(10^x\)</span> it spaces the decade exponents <spanclass="math">\(x\)</span> linearly
<p>Another fundamental signal in signal processing, the Heaviside step function <spanclass="math">\(H[n]\)</span>
<p>Another fundamental signal in signal processing, the Heaviside step function <spanclass="math">\(H[n]\)</span>
is the integral of the Dirac delta impulse and represents a signal that switches on
is the integral of the Dirac delta impulse and represents a signal that switches on
@ -156,14 +200,9 @@ at a specified time and then stays on indefinitely. In discrete time:</p>
<p>The <code>Step</code> routines generates a Heaviside step, but just like the Kronecker Delta impulse
<p>The <code>Step</code> routines generates a Heaviside step, but just like the Kronecker Delta impulse
also accepts a sample delay parameter <spanclass="math">\(d\)</span> and amplitude <spanclass="math">\(A\)</span> such that the resulting generated signal is</p>
also accepts a sample delay parameter <spanclass="math">\(d\)</span> and amplitude <spanclass="math">\(A\)</span> such that the resulting generated signal is</p>
<p><spanclass="math">\[s[n] = A\cdot H[n-d] = \begin{cases} 0 &\mbox{if } n < d \\ A & \mbox{if } n \ge d\end{cases}\]</span></p>
<p><spanclass="math">\[s[n] = A\cdot H[n-d] = \begin{cases} 0 &\mbox{if } n < d \\ A & \mbox{if } n \ge d\end{cases}\]</span></p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">a.Select(x <spanclass="o">=</span><spanclass="o">></span> x <spanclass="o">+</span><spanclass="n">1.0</span>).ToArray();
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">a.Select(x <spanclass="o">=</span><spanclass="o">></span> x <spanclass="o">+</span><spanclass="n">1.0</span>).ToArray();
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>Similarly, with <code>Map2</code> you can also map a function accepting two inputs to two input arrays:</p>
<p>Similarly, with <code>Map2</code> you can also map a function accepting two inputs to two input arrays:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">a.Zip(b, (x, y) <spanclass="o">=</span><spanclass="o">></span> x <spanclass="o">+</span> y).ToArray();
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">a.Zip(b, (x, y) <spanclass="o">=</span><spanclass="o">></span> x <spanclass="o">+</span> y).ToArray();
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<divclass="tip"id="fs1">val x : float</div>
<divclass="fsdocs-tip"id="fs1">val x : float</div>
<divclass="tip"id="fs2">val sin : value:'T ->'T (requires member Sin)<br/><br/>Full name: Microsoft.FSharp.Core.Operators.sin</div>
<divclass="fsdocs-tip"id="fs2">val sin : value:'T ->'T (requires member Sin)<br/><em><summary>Sine of the given number</summary><br/><param name="value">The input value.</param><br/><returns>The sine of the input.</returns></em></div>
aus Microsoft.FSharp.Collections<br/><em><summary>Contains operations for working with arrays.</summary><br/><remarks>
<divclass="span3">
See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/arrays">F# Language Guide - Arrays</a>.
<ulclass="nav nav-list"id="menu">
</remarks></em></div>
<divclass="fsdocs-tip"id="fs4">val map : mapping:('T ->'U) -> array:'T [] ->'U []<br/><em><summary>Builds a new array whose elements are the results of applying the given function
<liclass="nav-header">Math.NET Numerics</li>
to each of the elements of the array.</summary><br/><param name="mapping">The function to transform elements of the array.</param><br/><param name="array">The input array.</param><br/><returns>The array of transformed elements.</returns><br/><exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception></em></div>
<divclass="fsdocs-tip"id="fs7">val map2 : mapping:('T1 ->'T2 ->'U) -> array1:'T1 [] -> array2:'T2 [] ->'U []<br/><em><summary>Builds a new collection whose elements are the results of applying the given function
raised.</summary><br/><param name="mapping">The function to transform the pairs of the input elements.</param><br/><param name="array1">The first input array.</param><br/><param name="array2">The second input array.</param><br/><exception cref="T:System.ArgumentException">Thrown when the input arrays differ in length.</exception><br/><exception cref="T:System.ArgumentNullException">Thrown when either of the input arrays is null.</exception><br/><returns>The array of transformed elements.</returns></em></div>
<li><ahref="https://numerics.mathdotnet.com/Users.html">Who is using Math.NET?</a></li>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<p><ahref="https://ipython.org/">iPython</a> provides a rich browser-based interactive notebook with support for code, text, mathematical expressions,
<p><ahref="https://ipython.org/">iPython</a> provides a rich browser-based interactive notebook with support for code, text, mathematical expressions,
inline plots and other rich media. <ahref="https://github.com/BayardRock/IfSharp">IfSharp</a>, developed by Bayard Rock, is an F# profile
inline plots and other rich media. <ahref="https://github.com/BayardRock/IfSharp">IfSharp</a>, developed by Bayard Rock, is an F# profile
for iPython with IntelliSense and embedded FSharp.Charting. Thanks to its NuGet support it can load other packages like Math.NET Numerics on demand.</p>
for iPython with IntelliSense and embedded FSharp.Charting. Thanks to its NuGet support it can load other packages like Math.NET Numerics on demand.</p>
@ -80,216 +155,146 @@ Since v3.3 the Math.NET Numerics F# package includes a script <code>MathNet.Nume
Unfortunately loading this script requires the exact version in the path - if you know a way to avoid this please let us know.</p>
Unfortunately loading this script requires the exact version in the path - if you know a way to avoid this please let us know.</p>
<divclass="fsdocs-tip"id="fs2">type obj = System.Object<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.Object" />.</summary><br/><category>Basic Types</category></em></div>
<divclass="fsdocs-tip"id="fs3">Multiple items<br/>val float : value:'T -> float (requires member op_Explicit)<br/><em><summary>Converts the argument to 64-bit float. This is a direct conversion for all
<divclass="tip"id="fs4">union case Option.Some: Value: 'T -> Option<'T></div>
primitive numeric types. For strings, the input is converted using <c>Double.Parse()</c>
<divclass="tip"id="fs5">union case Option.None: Option<'T></div>
with InvariantCulture settings. Otherwise the operation requires an appropriate
static conversion method on the input type.</summary><br/><param name="value">The input value.</param><br/><returns>The converted float</returns></em><br/><br/>--------------------<br/>[<Struct>]
<divclass="tip"id="fs7">val v : 'T (requires member IsPositiveInfinity)</div>
type float = System.Double<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.Double" />.</summary><br/><category>Basic Types</category></em><br/><br/>--------------------<br/>type float<'Measure> =
float<br/><em><summary>The type of double-precision floating point numbers, annotated with a unit of measure.
<divclass="tip"id="fs9">val v : 'T (requires member IsNegativeInfinity)</div>
The unit of measure is erased in compiled code and when values of this type
<divclass="tip"id="fs10">val v : 'T (requires member IsNaN)</div>
are analyzed using reflection. The type is representationally equivalent to
<divclass="tip"id="fs11">val formatMathValue : floatFormat:string -> _arg1:'a -> string (requires member IsNaN and member IsPositiveInfinity and member IsNegativeInfinity)<br/><br/>Full name: IFsharpNotebook.formatMathValue</div>
<see cref="T:System.Double" />.</summary><br/><category index="6">Basic Types with Units of Measure</category></em></div>
<divclass="fsdocs-tip"id="fs4">Union-Fall Option.Some: Value: 'T -> Option<'T><br/><em><summary>The representation of "Value of type 'T"</summary><br/><param name="Value">The input value.</param><br/><returns>An option representing the value.</returns></em></div>
<divclass="fsdocs-tip"id="fs6">Multiple items<br/>val float32 : value:'T -> float32 (requires member op_Explicit)<br/><em><summary>Converts the argument to 32-bit float. This is a direct conversion for all
static conversion method on the input type.</summary><br/><param name="value">The input value.</param><br/><returns>The converted float32</returns></em><br/><br/>--------------------<br/>[<Struct>]
<divclass="tip"id="fs18">val v : float</div>
type float32 = System.Single<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.Single" />.</summary><br/><category>Basic Types</category></em><br/><br/>--------------------<br/>type float32<'Measure> =
type bool = System.Boolean<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.Boolean" />.</summary><br/><category>Basic Types</category></em></div>
<divclass="fsdocs-tip"id="fs11">val formatMathValue : floatFormat:string -> _arg1:'a -> string (requires member IsNaN and member IsPositiveInfinity and member IsNegativeInfinity)</div>
<divclass="fsdocs-tip"id="fs13">Multiple items<br/>val string : value:'T -> string<br/><em><summary>Converts the argument to a string using <c>ToString</c>.</summary><br/><remarks>For standard integer and floating point values the and any type that implements <c>IFormattable</c><c>ToString</c> conversion uses <c>CultureInfo.InvariantCulture</c>. </remarks><br/><param name="value">The input value.</param><br/><returns>The converted string.</returns></em><br/><br/>--------------------<br/>type string = System.String<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.String" />.</summary><br/><category>Basic Types</category></em></div>
<divclass="fsdocs-tip"id="fs14">aktive Erkennung PositiveInfinity: 'T -> unit option</div>
<divclass="fsdocs-tip"id="fs15">aktive Erkennung NegativeInfinity: 'T -> unit option</div>
<divclass="fsdocs-tip"id="fs16">aktive Erkennung NaN: 'T -> unit option</div>
<divclass="fsdocs-tip"id="fs28">val concat : sep:string -> strings:seq<string> -> string<br/><em><summary>Returns a new string made by concatenating the given strings
with separator <c>sep</c>, that is <c>a1 + sep + ... + sep + aN</c>.</summary><br/><param name="sep">The separator string to be inserted between the strings
of the input sequence.</param><br/><param name="strings">The sequence of strings to be concatenated.</param><br/><returns>A new string consisting of the concatenated strings separated by
the separation string.</returns><br/><exception cref="T:System.ArgumentNullException">Thrown when <c>strings</c> is null.</exception></em></div>
<divclass="fsdocs-tip"id="fs29">val formatVector : vector:Vector<'T> -> string (requires default constructor and value type and 'T :> System.ValueType)</div>
<divclass="fsdocs-tip"id="fs30">val vector : Vector<'T> (requires default constructor and value type and 'T :> System.ValueType)</div>
<li><ahref="https://numerics.mathdotnet.com/Users.html">Who is using Math.NET?</a></li>
static member Abs<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<'T>
<liclass="nav-header">Contributing</li>
static member Add<'T (requires default constructor and value type and 'T :> ValueType)> : left: Vector<'T> * right: Vector<'T> -> Vector<'T>
static member AndNot<'T (requires default constructor and value type and 'T :> ValueType)> : left: Vector<'T> * right: Vector<'T> -> Vector<'T>
static member AsVectorByte<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<byte>
static member AsVectorDouble<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<float>
static member AsVectorInt16<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<int16>
static member AsVectorInt32<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<int>
<liclass="nav-header">Getting Help</li>
static member AsVectorInt64<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<int64>
static member AsVectorSByte<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<sbyte>
static member AsVectorSingle<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<float32>
...<br/><em><summary>Provides a collection of static convenience methods for creating, manipulating, combining, and converting generic vectors.</summary></em><br/><br/>--------------------<br/>[<Struct>]
<liclass="nav-header">Getting Started</li>
type Vector<'T (requires default constructor and value type and 'T :> ValueType)> =
...<br/><em><summary>Represents a single vector of a specified numeric type that is suitable for low-level optimization of parallel algorithms.</summary><br/><typeparam name="T">The vector type. <c>T</c> can be any primitive numeric type.</typeparam></em><br/><br/>--------------------<br/>Vector ()<br/>Vector(values: System.ReadOnlySpan<byte>) : Vector<'T><br/>Vector(values: System.ReadOnlySpan<'T>) : Vector<'T><br/>Vector(values: System.Span<'T>) : Vector<'T><br/>Vector(value: 'T) : Vector<'T><br/>Vector(values: 'T []) : Vector<'T><br/>Vector(values: 'T [], index: int) : Vector<'T></div>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<h1><aname="Fourier-and-related-linear-integral-transforms"class="anchor"href="#Fourier-and-related-linear-integral-transforms">Fourier and related linear integral transforms</a></h1>
<h1><aname="Fourier-and-related-linear-integral-transforms"class="anchor"href="#Fourier-and-related-linear-integral-transforms">Fourier and related linear integral transforms</a></h1>
<p>Math.NET Numerics currently supports two linear integral transforms: The discrete Fourier
<p>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
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
spectrum, but while the Fourier transform operates on complex values, the Hartley transform
@ -75,15 +150,7 @@ We provide implementations of the following algorithms:</p>
</ul>
</ul>
<p>Furthermore, the <em><ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.IntegralTransforms/Fourier.htm">Transform</a></em> class provides a shortcut for the Bluestein FFT using static methods which are even easier to use: <em><ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.IntegralTransforms/Transform.htm#FourierForward">FourierForward</a></em>, <em><ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.IntegralTransforms/Transform.htm#FourierInverse">FourierInverse</a></em>.</p>
<p>Furthermore, the <em><ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.IntegralTransforms/Fourier.htm">Transform</a></em> class provides a shortcut for the Bluestein FFT using static methods which are even easier to use: <em><ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.IntegralTransforms/Transform.htm#FourierForward">FourierForward</a></em>, <em><ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.IntegralTransforms/Transform.htm#FourierInverse">FourierInverse</a></em>.</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// create a complex sample vector of length 96</span>
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
<spanclass="l">6: </span>
<spanclass="l">7: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// create a complex sample vector of length 96</span>
t <spanclass="o">=</span><spanclass="o">></span><spanclass="k">new</span> Complex(<spanclass="n">1.0</span><spanclass="o">/</span> (t <spanclass="o">*</span> t <spanclass="o">+</span><spanclass="n">1.0</span>), t <spanclass="o">/</span> (t <spanclass="o">*</span> t <spanclass="o">+</span><spanclass="n">1.0</span>)),
t <spanclass="o">=</span><spanclass="o">></span><spanclass="k">new</span> Complex(<spanclass="n">1.0</span><spanclass="o">/</span> (t <spanclass="o">*</span> t <spanclass="o">+</span><spanclass="n">1.0</span>), t <spanclass="o">/</span> (t <spanclass="o">*</span> t <spanclass="o">+</span><spanclass="n">1.0</span>)),
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<p>The following double precision numerical integration or quadrature rules are supported in Math.NET Numerics under the <code>MathNet.Numerics.Integration</code> namespace. Unless stated otherwise, the examples below evaluate the integral <spanclass="math">\(\int_0^{10} x^2 \, dx = \frac{1000}{3} \approx 333.\overline{3}\)</span>.</p>
<p>The following double precision numerical integration or quadrature rules are supported in Math.NET Numerics under the <code>MathNet.Numerics.Integration</code> namespace. Unless stated otherwise, the examples below evaluate the integral <spanclass="math">\(\int_0^{10} x^2 \, dx = \frac{1000}{3} \approx 333.\overline{3}\)</span>.</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Adaptive approximation with a relative error of 1e-5</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
<spanclass="l">13: </span>
<spanclass="l">14: </span>
<spanclass="l">15: </span>
<spanclass="l">16: </span>
<spanclass="l">17: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Adaptive approximation with a relative error of 1e-5</span>
<p>The Double-Exponential Transformation is suited for integration of smooth functions with no discontinuities, derivative discontinuities, and poles inside the interval.</p>
<p>The Double-Exponential Transformation is suited for integration of smooth functions with no discontinuities, derivative discontinuities, and poles inside the interval.</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Approximate using a relative error of 1e-5.</span>
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Approximate using a relative error of 1e-5.</span>
<spanclass="c">// Approximate value using a relative error of 1e-5 is: 333.333333333332</span>
<spanclass="c">// Approximate value using a relative error of 1e-5 is: 333.333333333332</span>
@ -142,20 +181,7 @@ Console.WriteLine(<span class="s">"Approximate value using a relative error of 1
<p>This algorithm calculates the abscissas and weights for a given order and integration interval. For efficiency, pre-computed abscissas and weights for the orders <spanclass="math">\(N = 2 - 20, \, 32, \, 64, \, 96, 100, \, 128, \, 256, \, 512, \, 1024\)</span> are used. Otherwise, they are calculated on the fly using Newton's method. For more information on the algorithm see <ahref="https://www.holoborodko.com/pavel/numerical-methods/numerical-integration/">[Holoborodko, Pavel] </a>.</p>
<p>This algorithm calculates the abscissas and weights for a given order and integration interval. For efficiency, pre-computed abscissas and weights for the orders <spanclass="math">\(N = 2 - 20, \, 32, \, 64, \, 96, 100, \, 128, \, 256, \, 512, \, 1024\)</span> are used. Otherwise, they are calculated on the fly using Newton's method. For more information on the algorithm see <ahref="https://www.holoborodko.com/pavel/numerical-methods/numerical-integration/">[Holoborodko, Pavel] </a>.</p>
<h3><aname="Abscissas-and-Weights"class="anchor"href="#Abscissas-and-Weights">Abscissas and Weights</a></h3>
<h3><aname="Abscissas-and-Weights"class="anchor"href="#Abscissas-and-Weights">Abscissas and Weights</a></h3>
<p>We'll first use the abscissas and weights to approximate an integral using a 5-point Gauss-Legendre rule</p>
<p>We'll first use the abscissas and weights to approximate an integral using a 5-point Gauss-Legendre rule</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Create a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Create a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<spanclass="k">double</span> sum <spanclass="o">=</span><spanclass="n">0</span>; <spanclass="c">// Will hold the approximate value of the integral</span>
<spanclass="k">double</span> sum <spanclass="o">=</span><spanclass="n">0</span>; <spanclass="c">// Will hold the approximate value of the integral</span>
@ -174,23 +200,7 @@ Console.WriteLine(<span class="s">"Approximate value is: "</span> <span class="o
<li><code>double GetWeight(int i)</code></li>
<li><code>double GetWeight(int i)</code></li>
</ul>
</ul>
<p>then use the properties <code>Abscissas</code> and <code>Weights</code></p>
<p>then use the properties <code>Abscissas</code> and <code>Weights</code></p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Create a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
<spanclass="l">13: </span>
<spanclass="l">14: </span>
<spanclass="l">15: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Create a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Create a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Create a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<p>For convenience, we provide an overloaded static method <code>double Integrate(...)</code> which preforms 1D and 2D integration of a function. The first parameter to the method is a delegate of type <code>Func<double, double></code> or <code>Func<double, double, double></code> for 1D and 2D integration respectively. So for example</p>
<p>For convenience, we provide an overloaded static method <code>double Integrate(...)</code> which preforms 1D and 2D integration of a function. The first parameter to the method is a delegate of type <code>Func<double, double></code> or <code>Func<double, double, double></code> for 1D and 2D integration respectively. So for example</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// 1D integration using a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// 1D integration using a 5-point Gauss-Legendre rule over the integration interval [0, 10]</span>
<spanclass="c">// Approximate value of the 1D integral is: 333.333333333333</span>
<spanclass="c">// Approximate value of the 1D integral is: 333.333333333333</span>
@ -260,87 +246,15 @@ Console.WriteLine(<span class="s">"Approximate value of the 2D integral is: "</s
<p>where we used <spanclass="math">\(\int_0^{10}\int_1^2 x^2 y^2 \,dydx = \frac{7000}{9} \approx 777.\overline{7}\)</span> for the 2D integral example.</p>
<p>where we used <spanclass="math">\(\int_0^{10}\int_1^2 x^2 y^2 \,dydx = \frac{7000}{9} \approx 777.\overline{7}\)</span> for the 2D integral example.</p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
@ -111,20 +178,12 @@ a_{m1} & a_{m2} & \cdots & a_{mn}
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>The resulting <spanclass="math">\(\mathbf{x}\)</span> is <spanclass="math">\([1,\;-2,\;-2]\)</span>, hence the solution <spanclass="math">\(x=1,\;y=-2,\;z=-2\)</span>.</p>
<p>The resulting <spanclass="math">\(\mathbf{x}\)</span> is <spanclass="math">\([1,\;-2,\;-2]\)</span>, hence the solution <spanclass="math">\(x=1,\;y=-2,\;z=-2\)</span>.</p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<h1><aname="Intel-Math-Kernel-Library-MKL"class="anchor"href="#Intel-Math-Kernel-Library-MKL">Intel Math Kernel Library (MKL)</a></h1>
<p>Math.NET Numerics is designed such that performance-sensitive algorithms
<p>Math.NET Numerics is designed such that performance-sensitive algorithms
can be swapped with alternative implementations by the concept of providers.
can be swapped with alternative implementations by the concept of providers.
There is currently only a provider for <ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.Providers.LinearAlgebra.Mkl/MklLinearAlgebraProvider.htm">linear algebra related routines</a>, but there
There is currently only a provider for <ahref="https://numerics.mathdotnet.com/api/MathNet.Numerics.Providers.LinearAlgebra.Mkl/MklLinearAlgebraProvider.htm">linear algebra related routines</a>, but there
@ -77,15 +152,11 @@ only a single platform, for example:</p>
</ul>
</ul>
<p>In order to leverage the MKL linear algebra provider, we need to make sure the .NET
<p>In order to leverage the MKL linear algebra provider, we need to make sure the .NET
runtime can find the native libraries (see below) and then enable it by calling:</p>
runtime can find the native libraries (see below) and then enable it by calling:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip"><codelang="sh">lionel:~ Lionel$ cd /Users/Lionel/Public/Git/GitHub/mathnet-numerics/src/NativeProviders/OSX
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip"><codelang="sh">lionel:~ Lionel$ cd /Users/Lionel/Public/Git/GitHub/mathnet-numerics/src/NativeProviders/OSX
lionel:OSX Lionel$ ls
lionel:OSX Lionel$ ls
mkl_build.sh
mkl_build.sh
lionel:OSX Lionel$ sh mkl_build.sh
lionel:OSX Lionel$ sh mkl_build.sh
@ -160,10 +226,7 @@ lionel:OSX Lionel$ sh mkl_build.sh
<p>Check the /x86 and /x64 folders in mathnet-numerics/out/MKL: you should now find the <code>libiomp5.dylib</code> and <code>MathNet.Numerics.MKL.dll</code> libaries.
<p>Check the /x86 and /x64 folders in mathnet-numerics/out/MKL: you should now find the <code>libiomp5.dylib</code> and <code>MathNet.Numerics.MKL.dll</code> libaries.
You need to add the path to the generated libraries in your <code>DYLD_LIBRARY_PATH</code> environment variable (which you can move to the folder of you choice before).
You need to add the path to the generated libraries in your <code>DYLD_LIBRARY_PATH</code> environment variable (which you can move to the folder of you choice before).
To do that, open your /Users/Lionel/.bas_profile.sh file with a text editor and add the following statements.</p>
To do that, open your /Users/Lionel/.bas_profile.sh file with a text editor and add the following statements.</p>
<h2><aname="Example-Intel-MKL-on-Linux-with-Mono"class="anchor"href="#Example-Intel-MKL-on-Linux-with-Mono">Example: Intel MKL on Linux with Mono</a></h2>
<h2><aname="Example-Intel-MKL-on-Linux-with-Mono"class="anchor"href="#Example-Intel-MKL-on-Linux-with-Mono">Example: Intel MKL on Linux with Mono</a></h2>
<p>We also provide MKL NuGet package for Linux if you do not want to build them yourself. Assuming you have
<p>We also provide MKL NuGet package for Linux if you do not want to build them yourself. Assuming you have
Mono and NuGet installed (here v3.2.8), you can fetch the MKL package of the right architecture
Mono and NuGet installed (here v3.2.8), you can fetch the MKL package of the right architecture
(x64 or x86, <code>uname -m</code> if you don't know) as usual:</p>
(x64 or x86, <code>uname -m</code> if you don't know) as usual:</p>
static member GetInvalidFileNameChars : unit -> char []
static member GetInvalidPathChars : unit -> char []
...<br/><em><summary>Performs operations on <see cref="T:System.String" /> instances that contain file or directory path information. These operations are performed in a cross-platform manner.</summary></em></div>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">List<MatlabMatrix> ms <spanclass="o">=</span> MatlabReader.List(<spanclass="s">"collection.mat"</span>);
<spanclass="l">2: </span>
<spanclass="l">3: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">List<MatlabMatrix> ms <spanclass="o">=</span> MatlabReader.List(<spanclass="s">"collection.mat"</span>);
Matrix<<spanclass="k">double</span>> Ad <spanclass="o">=</span> MatlabReader.Unpack<<spanclass="k">double</span>>(ms.Find(m <spanclass="o">=</span><spanclass="o">></span> m.Name <spanclass="o">=</span><spanclass="o">=</span><spanclass="s">"Ad"</span>));
Matrix<<spanclass="k">double</span>> Ad <spanclass="o">=</span> MatlabReader.Unpack<<spanclass="k">double</span>>(ms.Find(m <spanclass="o">=</span><spanclass="o">></span> m.Name <spanclass="o">=</span><spanclass="o">=</span><spanclass="s">"Ad"</span>));
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// write a single matrix "myMatrix" and name it "m1".</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// write a single matrix "myMatrix" and name it "m1".</span>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// create a dense matrix with 3 rows and 4 columns</span>
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
<spanclass="l">6: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// create a dense matrix with 3 rows and 4 columns</span>
<spanclass="c">// filled with random numbers sampled from the standard distribution</span>
<spanclass="c">// filled with random numbers sampled from the standard distribution</span>
Matrix<<spanclass="k">double</span>> m <spanclass="o">=</span> Matrix<<spanclass="k">double</span>>.Build.Random(<spanclass="n">3</span>, <spanclass="n">4</span>);
Matrix<<spanclass="k">double</span>> m <spanclass="o">=</span> Matrix<<spanclass="k">double</span>>.Build.Random(<spanclass="n">3</span>, <spanclass="n">4</span>);
@ -125,14 +193,7 @@ Vector<<span class="k">double</span>> v <span class="o">=</span> Vector<
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>Since within an application you often only work with one specific data type, a common trick to keep this a bit shorter
<p>Since within an application you often only work with one specific data type, a common trick to keep this a bit shorter
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> M <spanclass="o">=</span> Matrix<<spanclass="k">double</span>>.Build;
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
<spanclass="l">6: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> M <spanclass="o">=</span> Matrix<<spanclass="k">double</span>>.Build;
<spanclass="k">var</span> V <spanclass="o">=</span> Vector<<spanclass="k">double</span>>.Build;
<spanclass="k">var</span> V <spanclass="o">=</span> Vector<<spanclass="k">double</span>>.Build;
<spanclass="c">// build the same as above</span>
<spanclass="c">// build the same as above</span>
@ -143,25 +204,7 @@ is to define shortcuts to the builders:</p>
so if we'd like to build a sparse matrix, intellisense will list all available options
so if we'd like to build a sparse matrix, intellisense will list all available options
together once you type <code>M.Sparse</code>.</p>
together once you type <code>M.Sparse</code>.</p>
<p>There are variants to generate synthetic matrices, for example:</p>
<p>There are variants to generate synthetic matrices, for example:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Copy of an existing matrix (can also be sparse or diagonal)</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
<spanclass="l">13: </span>
<spanclass="l">14: </span>
<spanclass="l">15: </span>
<spanclass="l">16: </span>
<spanclass="l">17: </span>
<spanclass="l">18: </span>
<spanclass="l">19: </span>
<spanclass="l">20: </span>
<spanclass="l">21: </span>
<spanclass="l">22: </span>
<spanclass="l">23: </span>
<spanclass="l">24: </span>
<spanclass="l">25: </span>
<spanclass="l">26: </span>
<spanclass="l">27: </span>
<spanclass="l">28: </span>
<spanclass="l">29: </span>
<spanclass="l">30: </span>
<spanclass="l">31: </span>
<spanclass="l">32: </span>
<spanclass="l">33: </span>
<spanclass="l">34: </span>
<spanclass="l">35: </span>
<spanclass="l">36: </span>
<spanclass="l">37: </span>
<spanclass="l">38: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Copy of an existing matrix (can also be sparse or diagonal)</span>
Matrix<<spanclass="k">double</span>> x <spanclass="o">=</span><spanclass="o">.</span><spanclass="o">.</span><spanclass="o">.</span>
Matrix<<spanclass="k">double</span>> x <spanclass="o">=</span><spanclass="o">.</span><spanclass="o">.</span><spanclass="o">.</span>
M.DenseOfMatrix(x);
M.DenseOfMatrix(x);
@ -263,24 +267,7 @@ M.DenseOfMatrixArray(x);
<p>Very similar variants also exist for sparse and diagonal matrices, prefixed
<p>Very similar variants also exist for sparse and diagonal matrices, prefixed
with <code>Sparse</code> and <code>Diagonal</code> respectively.</p>
with <code>Sparse</code> and <code>Diagonal</code> respectively.</p>
<p>The approach for vectors is exactly the same:</p>
<p>The approach for vectors is exactly the same:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Standard-distributed random vector of length 10</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
<spanclass="l">13: </span>
<spanclass="l">14: </span>
<spanclass="l">15: </span>
<spanclass="l">16: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// Standard-distributed random vector of length 10</span>
V.Random(<spanclass="n">10</span>);
V.Random(<spanclass="n">10</span>);
<spanclass="c">// All-zero vector of length 10</span>
<spanclass="c">// All-zero vector of length 10</span>
@ -299,104 +286,59 @@ V.Dense(x);
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<h3><aname="Creating-matrices-and-vectors-in-F"class="anchor"href="#Creating-matrices-and-vectors-in-F">Creating matrices and vectors in F#</a></h3>
<h3><aname="Creating-matrices-and-vectors-in-F"class="anchor"href="#Creating-matrices-and-vectors-in-F">Creating matrices and vectors in F#</a></h3>
<p>In F# we can use the builders just like in C#, but we can also use the F# modules:</p>
<p>In F# we can use the builders just like in C#, but we can also use the F# modules:</p>
<spanclass="math">\(\mathbf{X}^T\mathbf y = \mathbf{X}^T\mathbf X \mathbf p\)</span> which we would like to solve
<spanclass="math">\(\mathbf{X}^T\mathbf y = \mathbf{X}^T\mathbf X \mathbf p\)</span> which we would like to solve
for <spanclass="math">\(p\)</span>. By matrix inversion we get <spanclass="math">\(\mathbf p = (\mathbf{X}^T\mathbf X)^{-1}(\mathbf{X}^T\mathbf y)\)</span>.
for <spanclass="math">\(p\)</span>. By matrix inversion we get <spanclass="math">\(\mathbf p = (\mathbf{X}^T\mathbf X)^{-1}(\mathbf{X}^T\mathbf y)\)</span>.
This can directly be translated to the following code:</p>
This can directly be translated to the following code:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">M.Random(<spanclass="n">4</span>,<spanclass="n">4</span>).ConditionNumber(); <spanclass="c">// e.g. 14.829</span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">M.Random(<spanclass="n">4</span>,<spanclass="n">4</span>).ConditionNumber(); <spanclass="c">// e.g. 14.829</span>
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<h2><aname="Trace-and-Determinant"class="anchor"href="#Trace-and-Determinant">Trace and Determinant</a></h2>
<h2><aname="Trace-and-Determinant"class="anchor"href="#Trace-and-Determinant">Trace and Determinant</a></h2>
<p>For a square matrix, the trace of a matrix is the sum of the elements on the main diagonal,
<p>For a square matrix, the trace of a matrix is the sum of the elements on the main diagonal,
@ -475,14 +406,7 @@ of a square matrix is the product of all its eigenvalues with multiplicities.
A matrix is said to be <em>singular</em> if its determinant is zero and <em>non-singular</em> otherwise.
A matrix is said to be <em>singular</em> if its determinant is zero and <em>non-singular</em> otherwise.
In the latter case the matrix is invertible and the linear equation system it
In the latter case the matrix is invertible and the linear equation system it
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">m.Clear(); <spanclass="c">// set all elements to 0</span>
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">m.Clear(); <spanclass="c">// set all elements to 0</span>
m.ClearColumn(<spanclass="n">2</span>); <spanclass="c">// set the 3rd column to 0 (0-based indexing)</span>
m.ClearColumn(<spanclass="n">2</span>); <spanclass="c">// set the 3rd column to 0 (0-based indexing)</span>
m.ClearColumns(<spanclass="n">1</span>,<spanclass="n">3</span>); <spanclass="c">// set the 2nd and 4th columns to 0 (params-array)</span>
m.ClearColumns(<spanclass="n">1</span>,<spanclass="n">3</span>); <spanclass="c">// set the 2nd and 4th columns to 0 (params-array)</span>
m.ClearSubMatrix(<spanclass="n">1</span>,<spanclass="n">2</span>,<spanclass="n">1</span>,<spanclass="n">2</span>); <spanclass="c">// set the 2x2 submatrix with offset 1,1 to zero</span>
m.ClearSubMatrix(<spanclass="n">1</span>,<spanclass="n">2</span>,<spanclass="n">1</span>,<spanclass="n">2</span>); <spanclass="c">// set the 2x2 submatrix with offset 1,1 to zero</span>
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>Because of the limitations of floating point numbers, we may want to set very small numbers to zero:</p>
<p>Because of the limitations of floating point numbers, we may want to set very small numbers to zero:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">m.CoerceZero(<spanclass="n">1</span>e<spanclass="n">-14</span>); <spanclass="c">// set all elements smaller than 1e-14 to 0</span>
<spanclass="l">2: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">m.CoerceZero(<spanclass="n">1</span>e<spanclass="n">-14</span>); <spanclass="c">// set all elements smaller than 1e-14 to 0</span>
m.CoerceZero(x <spanclass="o">=</span><spanclass="o">></span> x <spanclass="o"><</span><spanclass="n">10</span>); <spanclass="c">// set all elements that match a predicate function to 0.</span>
m.CoerceZero(x <spanclass="o">=</span><spanclass="o">></span> x <spanclass="o"><</span><spanclass="n">10</span>); <spanclass="c">// set all elements that match a predicate function to 0.</span>
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>Even though matrices and vectors are mutable, their dimension is fixed and cannot be changed
<p>Even though matrices and vectors are mutable, their dimension is fixed and cannot be changed
after creation. However, we can still insert or remove rows or columns, or concatenate matrices together.
after creation. However, we can still insert or remove rows or columns, or concatenate matrices together.
But all these operations will create and return a new instance.</p>
But all these operations will create and return a new instance.</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> m<spanclass="n">2</span><spanclass="o">=</span> m.RemoveRow(<spanclass="n">2</span>); <spanclass="c">// remove the 3rd rows</span>
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
<spanclass="l">6: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> m<spanclass="n">2</span><spanclass="o">=</span> m.RemoveRow(<spanclass="n">2</span>); <spanclass="c">// remove the 3rd rows</span>
<spanclass="k">var</span> m<spanclass="n">3</span><spanclass="o">=</span> m<spanclass="n">2</span>.RemoveColumn(<spanclass="n">3</span>); <spanclass="c">// remove the 4th column</span>
<spanclass="k">var</span> m<spanclass="n">3</span><spanclass="o">=</span> m<spanclass="n">2</span>.RemoveColumn(<spanclass="n">3</span>); <spanclass="c">// remove the 4th column</span>
<spanclass="k">var</span> m<spanclass="n">4</span><spanclass="o">=</span> m.Stack(m<spanclass="n">2</span>); <spanclass="c">// new matrix with m on top and m2 on the bottom</span>
<spanclass="k">var</span> m<spanclass="n">4</span><spanclass="o">=</span> m.Stack(m<spanclass="n">2</span>); <spanclass="c">// new matrix with m on top and m2 on the bottom</span>
@ -679,21 +551,13 @@ of applying a function to its value. Or, if indexed, to its index and value.</p>
<li><strong>MapIndexed(f,zeros)</strong>: indexed variant of Map.</li>
<li><strong>MapIndexed(f,zeros)</strong>: indexed variant of Map.</li>
</ul>
</ul>
<p>Example: Convert a complex vector to a real vector containing only the real parts in C#:</p>
<p>Example: Convert a complex vector to a real vector containing only the real parts in C#:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">Vector<Complex> u <spanclass="o">=</span> Vector<Complex>.Build.Random(<spanclass="n">10</span>);
<spanclass="l">2: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">Vector<Complex> u <spanclass="o">=</span> Vector<Complex>.Build.Random(<spanclass="n">10</span>);
Vector<Double> v <spanclass="o">=</span> u.Map(c <spanclass="o">=</span><spanclass="o">></span> c.Real);
Vector<Double> v <spanclass="o">=</span> u.Map(c <spanclass="o">=</span><spanclass="o">></span> c.Real);
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip"><codelang="text">// var m = Matrix<double>.Build.Random(5,100,42); // 42 = random seed
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
<spanclass="l">13: </span>
<spanclass="l">14: </span>
<spanclass="l">15: </span>
<spanclass="l">16: </span>
<spanclass="l">17: </span>
<spanclass="l">18: </span>
<spanclass="l">19: </span>
<spanclass="l">20: </span>
<spanclass="l">21: </span>
<spanclass="l">22: </span>
<spanclass="l">23: </span>
<spanclass="l">24: </span>
<spanclass="l">25: </span>
<spanclass="l">26: </span>
<spanclass="l">27: </span>
<spanclass="l">28: </span>
<spanclass="l">29: </span>
<spanclass="l">30: </span>
<spanclass="l">31: </span>
<spanclass="l">32: </span>
<spanclass="l">33: </span>
<spanclass="l">34: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip"><codelang="text">// var m = Matrix<double>.Build.Random(5,100,42); // 42 = random seed
// m.ToString()
// m.ToString()
DenseMatrix 5x100-Double
DenseMatrix 5x100-Double
@ -917,112 +680,99 @@ DenseMatrix 5x100-Double
to load the MathNet.Numerics.fsx script of the F# package. Besides loading
to load the MathNet.Numerics.fsx script of the F# package. Besides loading
the assemblies it also adds proper FSI printers for both matrices and vectors.</p>
the assemblies it also adds proper FSI printers for both matrices and vectors.</p>
<divclass="fsdocs-tip"id="fs4">Multiple items<br/>val float : value:'T -> float (requires member op_Explicit)<br/><em><summary>Converts the argument to 64-bit float. This is a direct conversion for all
static conversion method on the input type.</summary><br/><param name="value">The input value.</param><br/><returns>The converted float</returns></em><br/><br/>--------------------<br/>[<Struct>]
<divclass="tip"id="fs8">val x : seq<seq<float>><br/><br/>Full name: Matrix.x</div>
type float = System.Double<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.Double" />.</summary><br/><category>Basic Types</category></em><br/><br/>--------------------<br/>type float<'Measure> =
The unit of measure is erased in compiled code and when values of this type
<divclass="tip"id="fs11">val c : int</div>
are analyzed using reflection. The type is representationally equivalent to
<divclass="tip"id="fs12">val r : int</div>
<see cref="T:System.Double" />.</summary><br/><category index="6">Basic Types with Units of Measure</category></em></div>
<divclass="fsdocs-tip"id="fs7">Multiple items<br/>val float32 : value:'T -> float32 (requires member op_Explicit)<br/><em><summary>Converts the argument to 32-bit float. This is a direct conversion for all
type float32 = System.Single<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.Single" />.</summary><br/><category>Basic Types</category></em><br/><br/>--------------------<br/>type float32<'Measure> =
float32<br/><em><summary>The type of single-precision floating point numbers, annotated with a unit of measure.
<divclass="tip"id="fs21">val m : obj<br/><br/>Full name: Matrix.m</div>
The unit of measure is erased in compiled code and when values of this type
<divclass="tip"id="fs22">val u : obj<br/><br/>Full name: Matrix.u</div>
are analyzed using reflection. The type is representationally equivalent to
<divclass="tip"id="fs23">Multiple items<br/>type Complex =<br/>  struct<br/>    new : real:float * imaginary:float -> Complex<br/>    member Equals : obj:obj -> bool + 1 overload<br/>    member GetHashCode : unit -> int<br/>    member Imaginary : float<br/>    member Magnitude : float<br/>    member Phase : float<br/>    member Real : float<br/>    member ToString : unit -> string + 3 overloads<br/>    static val Zero : Complex<br/>    static val One : Complex<br/>    ...<br/>  end<br/><br/>Full name: System.Numerics.Complex<br/><br/>--------------------<br/>Complex()<br/>Complex(real: float, imaginary: float) : unit</div>
<see cref="T:System.Single" />.
<divclass="tip"id="fs24">val v : obj<br/><br/>Full name: Matrix.v</div>
</summary><br/><category>Basic Types with Units of Measure</category></em></div>
<divclass="fsdocs-tip"id="fs8">val x : seq<seq<float>></div>
</div>
<divclass="fsdocs-tip"id="fs9">Modul Seq
<divclass="span3">
<ulclass="nav nav-list"id="menu">
aus Microsoft.FSharp.Collections<br/><em><summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary></em></div>
<divclass="fsdocs-tip"id="fs10">val init : count:int -> initializer:(int ->'T) -> seq<'T><br/><em><summary>Generates a new sequence which, when iterated, will return successive
<liclass="nav-header">Math.NET Numerics</li>
elements by calling the given function, up to the given count. Each element is saved after its
individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks><br/><param name="count">The maximum number of items to generate for the sequence.</param><br/><param name="initializer">A function that generates an item in the sequence from a given index.</param><br/><returns>The result sequence.</returns><br/><exception cref="T:System.ArgumentException">Thrown when count is negative.</exception></em></div>
static member Abs<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<'T>
static member Add<'T (requires default constructor and value type and 'T :> ValueType)> : left: Vector<'T> * right: Vector<'T> -> Vector<'T>
static member AndNot<'T (requires default constructor and value type and 'T :> ValueType)> : left: Vector<'T> * right: Vector<'T> -> Vector<'T>
static member AsVectorByte<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<byte>
static member AsVectorDouble<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<float>
static member AsVectorInt16<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<int16>
static member AsVectorInt32<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<int>
static member AsVectorInt64<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<int64>
static member AsVectorSByte<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<sbyte>
static member AsVectorSingle<'T (requires default constructor and value type and 'T :> ValueType)> : value: Vector<'T> -> Vector<float32>
...<br/><em><summary>Provides a collection of static convenience methods for creating, manipulating, combining, and converting generic vectors.</summary></em><br/><br/>--------------------<br/>[<Struct>]
type Vector<'T (requires default constructor and value type and 'T :> ValueType)> =
new : values: ReadOnlySpan<byte> -> unit + 5 Überladungen
member CopyTo : destination: Span<byte> -> unit + 3 Überladungen
member Equals : other: Vector<'T> -> bool + 1 Überladung
member GetHashCode : unit -> int
member ToString : unit -> string + 2 Überladungen
member TryCopyTo : destination: Span<byte> -> bool + 1 Überladung
...<br/><em><summary>Represents a single vector of a specified numeric type that is suitable for low-level optimization of parallel algorithms.</summary><br/><typeparam name="T">The vector type. <c>T</c> can be any primitive numeric type.</typeparam></em><br/><br/>--------------------<br/>Vector ()<br/>Vector(values: System.ReadOnlySpan<byte>) : Vector<'T><br/>Vector(values: System.ReadOnlySpan<'T>) : Vector<'T><br/>Vector(values: System.Span<'T>) : Vector<'T><br/>Vector(value: 'T) : Vector<'T><br/>Vector(values: 'T []) : Vector<'T><br/>Vector(values: 'T [], index: int) : Vector<'T></div>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// distribution parameters must be passed as arguments</span>
<spanclass="l">2: </span>
<spanclass="l">3: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// distribution parameters must be passed as arguments</span>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="fsharp"><spanclass="c">// using the default number generator (SystemRandomSource.Default)</span>
<h2><aname="Distribution-Functions-and-Properties"class="anchor"href="#Distribution-Functions-and-Properties">Distribution Functions and Properties</a></h2>
<h2><aname="Distribution-Functions-and-Properties"class="anchor"href="#Distribution-Functions-and-Properties">Distribution Functions and Properties</a></h2>
<p>Distributions can not just be used to generate non-uniform random samples.
<p>Distributions can not just be used to generate non-uniform random samples.
Once parametrized they can compute a variety of distribution properties
Once parametrized they can compute a variety of distribution properties
or evaluate distribution functions. Because it is often numerically more stable
or evaluate distribution functions. Because it is often numerically more stable
and faster to compute and work with such quantities in the logarithmic domain,
and faster to compute and work with such quantities in the logarithmic domain,
some of them are also available with the <code>Ln</code>-suffix.</p>
some of them are also available with the <code>Ln</code>-suffix.</p>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="fsharp"><spanclass="c">// distribution properties of the gamma we've configured above</span>
aus Microsoft.FSharp.Collections<br/><em><summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary></em></div>
<divclass="tip"id="fs12">val take : count:int -> source:seq<'T> -> seq<'T><br/><br/>Full name: Microsoft.FSharp.Collections.Seq.take</div>
<divclass="fsdocs-tip"id="fs12">val take : count:int -> source:seq<'T> -> seq<'T><br/><em><summary>Returns the first N elements of the sequence.</summary><br/><remarks>Throws <c>InvalidOperationException</c>
returns as many items as the sequence contains instead of throwing an exception.</remarks><br/><param name="count">The number of items to take.</param><br/><param name="source">The input sequence.</param><br/><returns>The result sequence.</returns><br/><exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception><br/><exception cref="T:System.ArgumentException">Thrown when the input sequence is empty.</exception><br/><exception cref="T:System.InvalidOperationException">Thrown when count exceeds the number of elements
<divclass="tip"id="fs16">val w : obj<br/><br/>Full name: Probability.w</div>
<divclass="fsdocs-tip"id="fs13">val toArray : source:seq<'T> ->'T []<br/><em><summary>Builds an array from the given collection.</summary><br/><param name="source">The input sequence.</param><br/><returns>The result array.</returns><br/><exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception></em></div>
<divclass="tip"id="fs17">val x : obj<br/><br/>Full name: Probability.x</div>
aus Microsoft.FSharp.Collections<br/><em><summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.list`1" />.</summary><br/><namespacedoc><summary>Operations for collections such as lists, arrays, sets, maps and sequences. See also
<a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/fsharp-collection-types">F# Collection Types</a> in the F# Language Guide.
<divclass="tip"id="fs27">val nic : obj<br/><br/>Full name: Probability.nic</div>
<divclass="tip"id="fs33">val s1 : rng:'a -> float<br/><br/>Full name: Probability.s1<br/><em><br/><br/> Transform a sample from a distribution</em></div>
interface IEnumerable<'T>
<divclass="tip"id="fs34">val rng : 'a</div>
member GetReverseIndex : rank:int * offset:int -> int
<divclass="tip"id="fs35">val tanh : value:'T ->'T (requires member Tanh)<br/><br/>Full name: Microsoft.FSharp.Core.Operators.tanh</div>
member GetSlice : startIndex:int option * endIndex:int option ->'T list
<divclass="tip"id="fs36">val s1f : rng:'a ->'b<br/><br/>Full name: Probability.s1f<br/><em><br/><br/> But we really want to transform the function, not the resulting sample:</em></div>
static member Cons : head:'T * tail:'T list ->'T list
<divclass="tip"id="fs37">val s1s : rng:'a ->'b<br/><br/>Full name: Probability.s1s<br/><em><br/><br/> Exactly the same also works with functions generating full sequences</em></div>
member Head : 'T
<divclass="tip"id="fs38">val s2 : rng:'a -> obj<br/><br/>Full name: Probability.s2<br/><em><br/><br/> Now with multiple distributions, e.g. their product:</em></div>
...<br/><em><summary>The type of immutable singly-linked lists.</summary><br/><remarks>Use the constructors <c>[]</c> and <c>::</c> (infix) to create values of this type, or
the notation <c>[1;2;3]</c>. Use the values in the <c>List</c> module to manipulate
values of this type, or pattern match against the values directly.
</remarks><br/><exclude /></em></div>
<divclass="fsdocs-tip"id="fs21">val ofSeq : source:seq<'T> ->'T list<br/><em><summary>Builds a new list from the given enumerable object.</summary><br/><param name="source">The input sequence.</param><br/><returns>The list of elements from the sequence.</returns></em></div>
<divclass="fsdocs-tip"id="fs22">val scan : folder:('State ->'T ->'State) -> state:'State -> source:seq<'T> -> seq<'State><br/><em><summary>Like fold, but computes on-demand and returns the sequence of intermediary and final results.</summary><br/><param name="folder">A function that updates the state with each element from the sequence.</param><br/><param name="state">The initial state.</param><br/><param name="source">The input sequence.</param><br/><returns>The resulting sequence of computed states.</returns><br/><exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception></em></div>
<divclass="fsdocs-tip"id="fs29">val sqrt : value:'T ->'U (requires member Sqrt)<br/><em><summary>Square root of the given number</summary><br/><param name="value">The input value.</param><br/><returns>The square root of the input.</returns></em></div>
<divclass="fsdocs-tip"id="fs35">val tanh : value:'T ->'T (requires member Tanh)<br/><em><summary>Hyperbolic tangent of the given number</summary><br/><param name="value">The input value.</param><br/><returns>The hyperbolic tangent of the input.</returns></em></div>
<divclass="fsdocs-tip"id="fs36">val s1f : rng:'a ->'b<br/><em> But we really want to transform the function, not the resulting sample:</em></div>
<divclass="fsdocs-tip"id="fs37">val s1s : rng:'a ->'b<br/><em> Exactly the same also works with functions generating full sequences</em></div>
<divclass="fsdocs-tip"id="fs38">val s2 : rng:'a -> obj<br/><em> Now with multiple distributions, e.g. their product:</em></div>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// create an array with 1000 random values</span>
<spanclass="l"> 2: </span>
<spanclass="l"> 3: </span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
<spanclass="l">13: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="c">// create an array with 1000 random values</span>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">System.Random random <spanclass="o">=</span><spanclass="k">new</span> SystemRandomSource();
<spanclass="l">2: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">System.Random random <spanclass="o">=</span><spanclass="k">new</span> SystemRandomSource();
<spanclass="k">let</span><spanonmouseout="hideTip(event, 'fs8', 11)"onmouseover="showTip(event, 'fs8', 11)"class="id">someRobustSeed</span><spanclass="o">=</span><spanclass="id">RandomSeed</span><spanclass="pn">.</span><spanclass="id">Robust</span><spanclass="pn">(</span><spanclass="pn">)</span><spanclass="c">// recommended, used by default</span>
</pre></td>
</code></pre>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="fsharp"><spanclass="k">let</span><spanonmouseout="hideTip(event, 'fs6', 9)"onmouseover="showTip(event, 'fs6', 9)"class="i">someTimeSeed</span><spanclass="o">=</span><spanclass="i">RandomSeed</span><spanclass="o">.</span><spanclass="i">Time</span>() <spanclass="c">// not recommended</span>
<spanclass="k">let</span><spanonmouseout="hideTip(event, 'fs8', 11)"onmouseover="showTip(event, 'fs8', 11)"class="i">someRobustSeed</span><spanclass="o">=</span><spanclass="i">RandomSeed</span><spanclass="o">.</span><spanclass="i">Robust</span>() <spanclass="c">// recommended, used by default</span>
</code></pre></td>
</tr>
</table>
<p>Let's generate random numbers like before, but this time with custom seed 42:</p>
<p>Let's generate random numbers like before, but this time with custom seed 42:</p>
<spanclass="k">let</span><spanonmouseout="hideTip(event, 'fs12', 16)"onmouseover="showTip(event, 'fs12', 16)"class="id">random1b</span><spanclass="o">=</span><spanclass="id">MersenneTwister</span><spanclass="pn">(</span><spanclass="n">42</span><spanclass="pn">)</span><spanclass="c">// with seed</span>
<spanclass="l"> 4: </span>
<spanclass="l"> 5: </span>
<spanclass="l"> 6: </span>
<spanclass="l"> 7: </span>
<spanclass="l"> 8: </span>
<spanclass="l"> 9: </span>
<spanclass="l">10: </span>
<spanclass="l">11: </span>
<spanclass="l">12: </span>
<spanclass="l">13: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="fsharp"><spanclass="c">// By using the normal constructor (random1 has type MersenneTwister) </span>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> a <spanclass="o">=</span> SystemRandomSource.Default;
<spanclass="l">2: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> a <spanclass="o">=</span> SystemRandomSource.Default;
<spanclass="k">var</span> b <spanclass="o">=</span> MersenneTwister.Default;
<spanclass="k">var</span> b <spanclass="o">=</span> MersenneTwister.Default;
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<h1><aname="Curve-Fitting-Linear-Regression"class="anchor"href="#Curve-Fitting-Linear-Regression">Curve Fitting: Linear Regression</a></h1>
<p>Regression is all about fitting a low order parametric model or curve to data, so we can
<p>Regression is all about fitting a low order parametric model or curve to data, so we can
reason about it or make predictions on points not covered by the data. Both data and
reason about it or make predictions on points not covered by the data. Both data and
model are known, but we'd like to find the model parameters that make the model fit best
model are known, but we'd like to find the model parameters that make the model fit best
@ -72,14 +147,7 @@ if you need the data to be reproduced exactly, have a look at interpolation inst
<spanclass="math">\(y : x \mapsto a + b x\)</span> to a set of points <spanclass="math">\((x_j,y_j)\)</span>, where <spanclass="math">\(x_j\)</span> and <spanclass="math">\(y_j\)</span> are scalars.
<spanclass="math">\(y : x \mapsto a + b x\)</span> to a set of points <spanclass="math">\((x_j,y_j)\)</span>, where <spanclass="math">\(x_j\)</span> and <spanclass="math">\(y_j\)</span> are scalars.
Assuming we have two double arrays for x and y, we can use <code>Fit.Line</code> to evaluate the <spanclass="math">\(a\)</span> and <spanclass="math">\(b\)</span>
Assuming we have two double arrays for x and y, we can use <code>Fit.Line</code> to evaluate the <spanclass="math">\(a\)</span> and <spanclass="math">\(b\)</span>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.Polynomial(xdata, ydata, <spanclass="n">3</span>); <spanclass="c">// polynomial of order 3</span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.Polynomial(xdata, ydata, <spanclass="n">3</span>); <spanclass="c">// polynomial of order 3</span>
<p>The <spanclass="math">\(x\)</span> in the linear model can also be a vector <spanclass="math">\(\mathbf x = [x^{(1)}\; x^{(2)} \cdots x^{(k)}]\)</span>
<p>The <spanclass="math">\(x\)</span> in the linear model can also be a vector <spanclass="math">\(\mathbf x = [x^{(1)}\; x^{(2)} \cdots x^{(k)}]\)</span>
@ -151,24 +209,14 @@ we end up at the simplest form of ordinary multiple regression:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.MultiDim(
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.MultiDim(
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> MultipleRegression.QR(
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> MultipleRegression.QR(
<spanclass="k">double</span>[] z <spanclass="o">=</span><spanclass="k">new</span>[] { z<spanclass="n">1</span>, z<spanclass="n">2</span>, z<spanclass="n">3</span>, <spanclass="o">.</span><spanclass="o">.</span><spanclass="o">.</span> };
<spanclass="k">double</span>[] z <spanclass="o">=</span><spanclass="k">new</span>[] { z<spanclass="n">1</span>, z<spanclass="n">2</span>, z<spanclass="n">3</span>, <spanclass="o">.</span><spanclass="o">.</span><spanclass="o">.</span> };
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>Then we can call Fit.LinearMultiDim with our model, which will return an array with the best fitting 4 parameters <spanclass="math">\(p_0, p_1, p_2, p_3\)</span>:</p>
<p>Then we can call Fit.LinearMultiDim with our model, which will return an array with the best fitting 4 parameters <spanclass="math">\(p_0, p_1, p_2, p_3\)</span>:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.LinearMultiDim(xy, z,
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.LinearMultiDim(xy, z,
d <spanclass="o">=</span><spanclass="o">></span><spanclass="n">1.0</span>, <spanclass="c">// p0*1.0</span>
d <spanclass="o">=</span><spanclass="o">></span><spanclass="n">1.0</span>, <spanclass="c">// p0*1.0</span>
d <spanclass="o">=</span><spanclass="o">></span> Math.Tanh(d[<spanclass="n">0</span>]), <spanclass="c">// p1*tanh(x)</span>
d <spanclass="o">=</span><spanclass="o">></span> Math.Tanh(d[<spanclass="n">0</span>]), <spanclass="c">// p1*tanh(x)</span>
d <spanclass="o">=</span><spanclass="o">></span> SpecialFunctions.DiGamma(d[<spanclass="n">0</span>]*d[<spanclass="n">1</span>]), <spanclass="c">// p2*psi(x*y)</span>
d <spanclass="o">=</span><spanclass="o">></span> SpecialFunctions.DiGamma(d[<spanclass="n">0</span>]*d[<spanclass="n">1</span>]), <spanclass="c">// p2*psi(x*y)</span>
@ -203,13 +242,7 @@ model in two dimensions:</p>
<p>Let's say we have the following model:</p>
<p>Let's say we have the following model:</p>
<p><spanclass="math">\[y : x \mapsto a + b \ln x\]</span></p>
<p><spanclass="math">\[y : x \mapsto a + b \ln x\]</span></p>
<p>For this case we can use the <code>Fit.LinearCombination</code> function:</p>
<p>For this case we can use the <code>Fit.LinearCombination</code> function:</p>
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.LinearCombination(
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">double</span>[] p <spanclass="o">=</span> Fit.LinearCombination(
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">Func<<spanclass="k">double</span>,<spanclass="k">double</span>> f <spanclass="o">=</span> Fit.LinearCombinationFunc(
<spanclass="l">2: </span>
<spanclass="l">3: </span>
<spanclass="l">4: </span>
<spanclass="l">5: </span>
<spanclass="l">6: </span>
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp">Func<<spanclass="k">double</span>,<spanclass="k">double</span>> f <spanclass="o">=</span> Fit.LinearCombinationFunc(
<tableclass="pre"><tr><tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> p <spanclass="o">=</span> WeightedRegression.Weighted(X,y,W);
</pre></td>
<tdclass="snippet"><preclass="fssnip highlighted"><codelang="csharp"><spanclass="k">var</span> p <spanclass="o">=</span> WeightedRegression.Weighted(X,y,W);
</code></pre></td></tr></table>
</code></pre></td></tr></table>
<p>Weighter regression becomes interesting if we can adapt them to the point of interest
<p>Weighter regression becomes interesting if we can adapt them to the point of interest
and e.g. dampen all data points far away. Unfortunately this way the model parameters
and e.g. dampen all data points far away. Unfortunately this way the model parameters
are dependent on the point of interest <spanclass="math">\(t\)</span>.</p>
are dependent on the point of interest <spanclass="math">\(t\)</span>.</p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<h1><aname="Who-is-using-Math-NET-Numerics"class="anchor"href="#Who-is-using-Math-NET-Numerics">Who is using Math.NET Numerics?</a></h1>
<p><em>This page collects anything that references and/or uses Math.NET Numerics.
<p><em>This page collects anything that references and/or uses Math.NET Numerics.
Feel free to <ahref="https://github.com/mathnet/mathnet-numerics/blob/master/docs/content/Users.md">add, edit or remove your own work</a> by submitting a pull request.</em></p>
Feel free to <ahref="https://github.com/mathnet/mathnet-numerics/blob/master/docs/content/Users.md">add, edit or remove your own work</a> by submitting a pull request.</em></p>
<metaname="description"content="Math.NET Numerics, providing methods and algorithms for numerical computations in science, engineering and every day use. .Net 4, .Net 3.5, SL5, Win8, WP8, PCL 47 and 136, Mono, Xamarin Android/iOS."/>
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael">
<metaname="author"content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<divclass="fsdocs-tip"id="fs3">Multiple items<br/>val float : value:'T -> float (requires member op_Explicit)<br/><em><summary>Converts the argument to 64-bit float. This is a direct conversion for all
primitive numeric types. For strings, the input is converted using <c>Double.Parse()</c>
with InvariantCulture settings. Otherwise the operation requires an appropriate
static conversion method on the input type.</summary><br/><param name="value">The input value.</param><br/><returns>The converted float</returns></em><br/><br/>--------------------<br/>[<Struct>]
type float = System.Double<br/><em><summary>An abbreviation for the CLI type <see cref="T:System.Double" />.</summary><br/><category>Basic Types</category></em><br/><br/>--------------------<br/>type float<'Measure> =
float<br/><em><summary>The type of double-precision floating point numbers, annotated with a unit of measure.
The unit of measure is erased in compiled code and when values of this type
are analyzed using reflection. The type is representationally equivalent to
<see cref="T:System.Double" />.</summary><br/><category index="6">Basic Types with Units of Measure</category></em></div>
Christoph Ruegg
5 years ago
