tsai
/
mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Math.NET Numerics
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
17 Commits
25 Branches
121 Tags
187 MiB
 
 
 
Tree: 9bb9b575fd
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '9bb9b575fd'
${ noResults }
mathnet-numerics/Generate.html

369 lines
26 KiB
Raw Blame History

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8"/>
<title>Generating Data
</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
<meta name="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."/>
<meta name="author" content="Christoph Ruegg, Marcus Cuda, Jurgen Van Gael"/>
<script src="https://code.jquery.com/jquery-1.8.0.js"></script>
<script src="https://code.jquery.com/ui/1.8.23/jquery-ui.js"></script>
<script src="https://netdna.bootstrapcdn.com/twitter-bootstrap/2.2.1/js/bootstrap.min.js"></script>
<link href="https://netdna.bootstrapcdn.com/twitter-bootstrap/2.2.1/css/bootstrap-combined.min.css" rel="stylesheet"/>
<link type="text/css" rel="stylesheet" href="https://numerics.mathdotnet.com/content/style.css" />
<style>
#main table:not(.pre) {
border: 1px solid #dddddd;
max-width: 100%;
border-style: solid;
border-width: 1px;
border-color: gray;
border-collapse: collapse;
border-right-width: 1px;
border-bottom-width: 1px;
margin-top: 15px;
margin-bottom: 25px;
}
#main table:not(.pre) th, #main table:not(.pre) td {
border: 1px solid #dddddd;
padding: 6px;
}
#main table:not(.pre) th p, #main table:not(.pre) td p {
margin-bottom: 5px;
}
</style>
<script type="text/javascript" src="https://numerics.mathdotnet.com/content/tips.js"></script>
<!-- HTML5 shim, for IE6-8 support of HTML5 elements -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
<![endif]-->
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
</head>
<body>
<div class="container">
<div class="masthead">
<ul class="nav nav-pills pull-right">
<li><a href="https://www.mathdotnet.com">Math.NET Project</a></li>
<li><a href="https://numerics.mathdotnet.com">Math.NET Numerics</a></li>
<li><a href="https://github.com/mathnet/mathnet-numerics">GitHub</a></li>
</ul>
<h3 class="muted">Math.NET Numerics</h3>
</div>
<hr />
<div class="row">
<div class="span9" id="main">
<h1><a name="Generating-Data" class="anchor" href="#Generating-Data">Generating Data</a></h1>
<p>Numerics is all about analyzing and manipulating numeric data. But unless you can read in data from an external
file, source or e.g. with the excellent <a href="https://fsharp.github.io/FSharp.Data/">F# Type Providers</a>,
you may need to generate synthetic or random data locally, or transform existing data into a new form.
The <code>Generate</code> class can help you in all these scenarios with a set of static functions generating either
an array or an IEnumerable sequence.</p>
<p>There is some overlap with LINQ, in case of F# also with some integrated language features and its fundamental types.
This is intended for simplicity and consistency between array and sequence operations, as LINQ only supports sequences.</p>
<h2><a name="Linear-Range" class="anchor" href="#Linear-Range">Linear Range</a></h2>
<p>Generates a linearly spaced array within the inclusive interval between start and stop,
and either a provided step or a step of 1.0. Linear range is equivalent to the
single colon <code>:</code> and double colon <code>::</code> operators in MATLAB.</p>
<p>F# has built in linear range support in array comprehensions with the colon operator:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
<span class="l">4: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp">[ <span class="n">10.0</span> <span class="o">..</span> <span class="n">2.0</span> <span class="o">..</span> <span class="n">15.0</span> ]
<span class="fsi">val it : float list = [10.0; 12.0; 14.0] </span>
[ <span class="k">for</span> <span class="i">x</span> <span class="k">in</span> <span class="n">10.0</span> <span class="o">..</span> <span class="n">2.0</span> <span class="o">..</span> <span class="n">15.0</span> <span class="k">-&gt;</span> <span class="i">sin</span> <span class="i">x</span> ]
<span class="fsi">val it : float list = [-0.5440211109; -0.536572918; 0.9906073557] </span>
</code></pre></td>
</tr>
</table>
<p>In C# you can get the same result with <code>LinearRange</code>:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Generate.LinearRange(<span class="n">10</span>, <span class="n">2</span>, <span class="n">15</span>); <span class="c">// returns array { 10.0, 12.0, 14.0 }</span>
Generate.LinearRangeMap(<span class="n">10</span>, <span class="n">2</span>, <span class="n">15</span>, Math.Sin); <span class="c">// applies sin(x) to each value</span>
</code></pre></td></tr></table>
<p>Most of the routines in the <code>Generate</code> class have variants with a <code>Map</code> suffix.
Instead of returning an array with the generated numbers, these routines instead
apply the generated numbers to a custom function and return an array with the results.
Similarly, some routines have variants with a <code>Sequence</code> suffix that return
lazy enumerable sequences instead of arrays.</p>
<h2><a name="Linear-Spaced-and-Log-Spaced" class="anchor" href="#Linear-Spaced-and-Log-Spaced">Linear-Spaced and Log-Spaced</a></h2>
<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.
This is equivalent to the linspace and logspace operators in MATLAB.</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Generate.LinearSpaced(<span class="n">11</span>, <span class="n">0.0</span>, <span class="n">1.0</span>); <span class="c">// returns array { 0.0, 0.1, 0.2, .., 1.0 }</span>
Generate.LinearSpacedMap(<span class="n">15</span>, <span class="n">0.0</span>, Math.Pi, Math.Sin); <span class="c">// applies sin(x) to each value</span>
</code></pre></td></tr></table>
<p>In F# you can also use:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
<span class="l">4: </span>
<span class="l">5: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="i">Generate</span><span class="o">.</span><span class="i">linearSpacedMap</span> <span class="n">15</span> <span class="n">0.0</span> <span class="i">Math</span><span class="o">.</span><span class="i">PI</span> <span class="i">sin</span>
<span class="fsi">val it : float [] = </span>
<span class="fsi"> [|0.0; 0.222520934; 0.4338837391; 0.6234898019; 0.7818314825; 0.9009688679; </span>
<span class="fsi"> 0.9749279122; 1.0; 0.9749279122; 0.9009688679; 0.7818314825; 0.6234898019; </span>
<span class="fsi"> 0.4338837391; 0.222520934; 1.224606354e-16|] </span>
</code></pre></td>
</tr>
</table>
<p><code>LogSpaced</code> works the same way but instead of the values <span class="math">\(10^x\)</span> it spaces the decade exponents <span class="math">\(x\)</span> linearly
between the provided two exponents.</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Generate.LogSpaced(<span class="n">4</span>,<span class="n">0</span>,<span class="n">3</span>); <span class="c">// returns array { 1, 10, 100, 1000 }</span>
</code></pre></td></tr></table>
<h2><a name="Kronecker-Delta-Impulse" class="anchor" href="#Kronecker-Delta-Impulse">Kronecker Delta Impulse</a></h2>
<p>The Kronecker delta <span class="math">\(\delta[n]\)</span> is a fundamental signal in time-discrete signal processing,
often referred to as <em>unit impulse</em>. When applied to a system, the resulting output is the system's <em>impulse response</em>.
It is closely related to the Dirac delta impulse function <span class="math">\(\delta(x)\)</span> in continuous signal processing.</p>
<p><span class="math">\[\delta[n] = \begin{cases} 0 &amp;\mbox{if } n \ne 0 \\ 1 &amp; \mbox{if } n = 0\end{cases}\]</span></p>
<p>The <code>Impulse</code> routine generates a Kronecker delta impulse, but also accepts a sample delay
parameter <span class="math">\(d\)</span> and amplitude <span class="math">\(A\)</span> such that the resulting generated signal is</p>
<p><span class="math">\[s[n] = A\cdot\delta[n-d] = \begin{cases} 0 &amp;\mbox{if } n \ne d \\ A &amp; \mbox{if } n = d\end{cases}\]</span></p>
<p>There is also a periodic version in <code>PeriodicImpulse</code> which accepts an additional <code>period</code> parameter.</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
<span class="l">4: </span>
<span class="l">5: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="i">Generate</span><span class="o">.</span><span class="i">Impulse</span>(<span class="n">8</span>, <span class="n">2.0</span>, <span class="n">3</span>)
<span class="fsi">val it : float [] = [|0.0; 0.0; 0.0; 2.0; 0.0; 0.0; 0.0; 0.0|] </span>
<span class="i">Generate</span><span class="o">.</span><span class="i">PeriodicImpulse</span>(<span class="n">8</span>, <span class="n">3</span>, <span class="n">10.0</span>, <span class="n">1</span>)
<span class="fsi">val it : float [] = [|0.0; 10.0; 0.0; 0.0; 10.0; 0.0; 0.0; 10.0|] </span>
</code></pre></td>
</tr>
</table>
<h2><a name="Heaviside-Step" class="anchor" href="#Heaviside-Step">Heaviside Step</a></h2>
<p>Another fundamental signal in signal processing, the Heaviside step function <span class="math">\(H[n]\)</span>
is the integral of the Dirac delta impulse and represents a signal that switches on
at a specified time and then stays on indefinitely. In discrete time:</p>
<p><span class="math">\[H[n] = \begin{cases} 0 &amp;\mbox{if } n &lt; 0 \\ 1 &amp; \mbox{if } n \ge 0\end{cases}\]</span></p>
<p>The <code>Step</code> routines generates a Heaviside step, but just like the Kronecker Delta impulse
also accepts a sample delay parameter <span class="math">\(d\)</span> and amplitude <span class="math">\(A\)</span> such that the resulting generated signal is</p>
<p><span class="math">\[s[n] = A\cdot H[n-d] = \begin{cases} 0 &amp;\mbox{if } n &lt; d \\ A &amp; \mbox{if } n \ge d\end{cases}\]</span></p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="i">Generate</span><span class="o">.</span><span class="i">Step</span>(<span class="n">8</span>, <span class="n">2.0</span>, <span class="n">3</span>)
<span class="fsi">val it : float [] = [|0.0; 0.0; 0.0; 2.0; 2.0; 2.0; 2.0; 2.0|] </span>
</code></pre></td>
</tr>
</table>
<h2><a name="Periodic-Sawtooth" class="anchor" href="#Periodic-Sawtooth">Periodic Sawtooth</a></h2>
<p>Generates an array of the given length with a periodic upper forward sawtooth signal,
i.e. a line starting at zero up to some amplitude <span class="math">\(A\)</span>, then drop back to zero instantly and start afresh.
The sawtooth can be used to turn any arbitrary function defined over the interval <span class="math">\([0,A)\)</span> into a
periodic function by repeating it continuously.</p>
<p>Mathematically, the sawtooth can be described using the fractional part function
<span class="math">\(\mathrm{frac}(x) \equiv x - \lfloor x \rfloor\)</span>, frequency <span class="math">\(\nu\)</span> and phase <span class="math">\(\theta\)</span> as</p>
<p><span class="math">\[s(x) = A\cdot\mathrm{frac}\left(x\nu+\frac{\theta}{A}\right)\]</span></p>
<p>In a trigonometric interpretation the signal represents the angular position <span class="math">\(\alpha\)</span> of a point moving endlessly
around a circle with radius <span class="math">\(\frac{A}{2\pi}\)</span> (and thus circumference <span class="math">\(A\)</span>) in constant speed,
normalized to strictly <span class="math">\(0\le\alpha &lt; A\)</span>.</p>
<p><code>Generate.Periodic(length,samplingRate,frequency,amplitude,phase,delay)</code></p>
<ul>
<li><strong>Sampling Rate</strong>: Number of samples <span class="math">\(r\)</span> per time unit. If the time unit is 1s, the sampling rate has unit Hz.</li>
<li>
<strong>Frequency</strong>: Frequency <span class="math">\(\nu\)</span> of the signal, in sawtooth-periods per time unit. If the time unit is 1s, the frequency has unit Hz.
For a desired number of samples <span class="math">\(n\)</span> per sawtooth-period and sampling rate <span class="math">\(r\)</span> choose <span class="math">\(\nu=\frac{r}{n}\)</span>.
</li>
<li>
<strong>Amplitude</strong>: The theoretical maximum value <span class="math">\(A\)</span>, which is never reached and logically equivalent to zero.
The circumference of the circle. Typically <span class="math">\(1\)</span> or <span class="math">\(2\pi\)</span>.
</li>
<li><strong>Phase</strong>: Optional initial value or phase offset. Contributes to <span class="math">\(\theta\)</span>.</li>
<li><strong>Delay</strong>: Optional initial delay, in samples. Contributes to <span class="math">\(\theta\)</span>.</li>
</ul>
<p>The equivalent map function accepts a custom map lambda as second argument after the length:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
<span class="l">4: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="i">Generate</span><span class="o">.</span><span class="i">periodicMap</span> <span class="n">15</span> ((<span class="o">+</span>) <span class="n">100.0</span>) <span class="n">1000.0</span> <span class="n">100.0</span> <span class="n">10.0</span> <span class="n">0.0</span> <span class="n">0</span>
<span class="fsi">val it : float [] = </span>
<span class="fsi"> [|100.0; 101.0; 102.0; 103.0; 104.0; 105.0; 106.0; 107.0; 108.0; 109.0; </span>
<span class="fsi"> 100.0; 101.0; 102.0; 103.0; 104.0|] </span>
</code></pre></td>
</tr>
</table>
<h2><a name="Sinusoidal" class="anchor" href="#Sinusoidal">Sinusoidal</a></h2>
<p>Generates a Sine wave array of the given length. This is equivalent to applying a scaled
trigonometric Sine function to a periodic sawtooth of amplitude <span class="math">\(2\pi\)</span>.</p>
<p><span class="math">\[s(x) = A\cdot\sin(2\pi\nu x + \theta)\]</span></p>
<p><code>Generate.Sinusoidal(length,samplingRate,frequency,amplitude,mean,phase,delay)</code></p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Generate.Sinusoidal(<span class="n">15</span>, <span class="n">1000.0</span>, <span class="n">100.0</span>, <span class="n">10.0</span>);
<span class="c">// returns array { 0, 5.9, 9.5, 9.5, 5.9, 0, -5.9, ... }</span>
</code></pre></td></tr></table>
<h2><a name="Random" class="anchor" href="#Random">Random</a></h2>
<p>Generate random sequences by sampling from a random distribution.</p>
<h4><a name="Uniform-Distribution" class="anchor" href="#Uniform-Distribution">Uniform Distribution</a></h4>
<p>Generate sample sequences distributed uniformly between 0 and 1.</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">Generate.Uniform(<span class="n">100</span>); <span class="c">// e.g. 0.867421787170424, 0.236744313145403, ... </span>
</code></pre></td></tr></table>
<p>Uniform supports mapping to functions with not only one but also two uniform variables
as arguments, with <code>UniformMap</code> and <code>UniformMap2</code>. As usual, lazy sequences can be
generated using the variants with the <code>Sequence</code> suffix, e.g. <code>UniformMap2Sequence</code>.</p>
<h4><a name="Non-Uniform-Distributions" class="anchor" href="#Non-Uniform-Distributions">Non-Uniform Distributions</a></h4>
<p>Instead of uniform we can also sample from other distributions.</p>
<ul>
<li><code>Normal</code> - sample an array or sequence form a normal distribution</li>
<li><code>Standard</code> - sample an array or sequence form a standard distribution</li>
</ul>
<p>In addition, the <code>Random</code> functions accept a custom distribution instance to sample
from. See the section about random numbers and probability distributions for details.</p>
<h2><a name="Map" class="anchor" href="#Map">Map</a></h2>
<p>Generates a new array or sequence where each new values is the result of applying the provided function
the the corresponding value in the input data.</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp"><span class="k">var</span> a <span class="o">=</span> <span class="k">new</span> <span class="k">double</span>[] { <span class="n">2.0</span>, <span class="n">4.0</span>, <span class="n">3.0</span>, <span class="n">6.0</span> };
Generate.Map(a, x <span class="o">=</span><span class="o">&gt;</span> x <span class="o">+</span> <span class="n">1.0</span>); <span class="c">// returns array { 3.0, 5.0, 4.0, 7.0 }</span>
</code></pre></td></tr></table>
<p>In F# you'd typically use the Array module to the same effect (and should continue to do so):</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="i">Array</span><span class="o">.</span><span class="i">map</span> ((<span class="o">+</span>) <span class="n">1.0</span>) <span class="i">a</span>
<span class="fsi">val it : float [] = [|3.0; 5.0; 4.0; 7.0|] </span>
</code></pre></td>
</tr>
</table>
<p>...but no equivalent operation is available in the .NET base class libraries (BCL) for C#.
You can use LINQ, but that operates on sequences instead of arrays:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">a.Select(x <span class="o">=</span><span class="o">&gt;</span> x <span class="o">+</span> <span class="n">1.0</span>).ToArray();
</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>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
<span class="l">3: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="k">let</span> <span class="i">b</span> <span class="o">=</span> [| <span class="n">1.0</span>; <span class="o">-</span><span class="n">1.0</span>; <span class="n">2.0</span>; <span class="o">-</span><span class="n">2.0</span> |]
<span class="i">Generate</span><span class="o">.</span><span class="i">Map2</span>(<span class="i">a</span>, <span class="i">b</span>, <span class="k">fun</span> <span class="i">x</span> <span class="i">y</span> <span class="k">-&gt;</span> <span class="i">x</span> <span class="o">+</span> <span class="i">y</span>)
<span class="fsi">val it : float [] = [|3.0; 3.0; 5.0; 4.0|] </span>
</code></pre></td>
</tr>
</table>
<p>Typical F# equivalent:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
<span class="l">2: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="fsharp"><span class="i">Array</span><span class="o">.</span><span class="i">map2</span> (<span class="o">+</span>) <span class="i">a</span> <span class="i">b</span>
<span class="fsi">val it : float [] = [|3.0; 3.0; 5.0; 4.0|] </span>
</code></pre></td>
</tr>
</table>
<p>And in C# with LINQ:</p>
<table class="pre"><tr><td class="lines"><pre class="fssnip"><span class="l">1: </span>
</pre></td>
<td class="snippet"><pre class="fssnip highlighted"><code lang="csharp">a.Zip(b, (x, y) <span class="o">=</span><span class="o">&gt;</span> x <span class="o">+</span> y).ToArray();
</code></pre></td></tr></table>
</div>
<div class="span3">
<ul class="nav nav-list" id="menu">
<li class="nav-header">Math.NET Numerics</li>
<li><a href="https://numerics.mathdotnet.com/Packages.html">NuGet & Binaries</a></li>
<li><a href="https://numerics.mathdotnet.com/ReleaseNotes.html">Release Notes</a></li>
<li><a href="https://numerics.mathdotnet.com/License.html">MIT/X11 License</a></li>
<li><a href="https://numerics.mathdotnet.com/Compatibility.html">Platform Support</a></li>
<li><a href="https://numerics.mathdotnet.com/api/">Class Reference</a></li>
<li><a href="https://github.com/mathnet/mathnet-numerics/issues">Issues & Bugs</a></li>
<li><a href="https://numerics.mathdotnet.com/Users.html">Who is using Math.NET?</a></li>
<li class="nav-header">Contributing</li>
<li><a href="https://numerics.mathdotnet.com/Contributors.html">Contributors</a></li>
<li><a href="https://numerics.mathdotnet.com/Contributing.html">Contributing</a></li>
<li><a href="https://numerics.mathdotnet.com/Build.html">Build & Tools</a></li>
<li><a href="http://feedback.mathdotnet.com/forums/2060-math-net-numerics">Your Ideas</a></li>
<li class="nav-header">Getting Help</li>
<li><a href="https://discuss.mathdotnet.com/c/numerics">Discuss</a></li>
<li><a href="https://stackoverflow.com/questions/tagged/mathdotnet">Stack Overflow</a></li>
<li class="nav-header">Getting Started</li>
<li><a href="https://numerics.mathdotnet.com/">Getting started</a></li>
<li><a href="https://numerics.mathdotnet.com/Constants.html">Constants</a></li>
<li>Floating-Point Numbers</li>
<li>Arbitrary Precision Numbers</li>
<li>Complex Numbers</li>
<li><a href="https://numerics.mathdotnet.com/Matrix.html">Matrices and Vectors</a></li>
<li><a href="https://numerics.mathdotnet.com/Euclid.html">Euclid & Number Theory</a></li>
<li>Combinatorics</li>
<li class="nav-header">Evaluation</li>
<li><a href="https://numerics.mathdotnet.com/Functions.html">Special Functions</a></li>
<li>Differentiation</li>
<li><a href="https://numerics.mathdotnet.com/Integration.html">Integration</a></li>
<li class="nav-header">Statistics/Probability</li>
<li><a href="https://numerics.mathdotnet.com/DescriptiveStatistics.html">Descriptive Statistics</a></li>
<li><a href="https://numerics.mathdotnet.com/Probability.html">Probability Distributions</a></li>
<li class="nav-header">Generation</li>
<li><a href="https://numerics.mathdotnet.com/Generate.html">Generating Data</a></li>
<li><a href="https://numerics.mathdotnet.com/Random.html">Random Numbers</a></li>
<li class="nav-header">Transformation</li>
<li>Fourier Transform (FFT)</li>
<li>Filtering & DSP</li>
<li>Window Functions</li>
<li class="nav-header">Solving Equations</li>
<li><a href="https://numerics.mathdotnet.com/LinearEquations.html">Linear Equation Systems</a></li>
<li>Nonlinear Root Finding</li>
<li class="nav-header">Optimization</li>
<li>Linear Least Squares</li>
<li>Nonlinear Optimization</li>
<li><a href="https://numerics.mathdotnet.com/Distance.html">Distance Metrics</a></li>
<li class="nav-header">Curve Fitting</li>
<li><a href="https://numerics.mathdotnet.com/Regression.html">Regression</a></li>
<li>Interpolation</li>
<li>Fourier Approximation</li>
<li class="nav-header">Native Providers</li>
<li><a href="https://numerics.mathdotnet.com/MKL.html">Intel MKL</a></li>
<li class="nav-header">Working Together</li>
<li><a href="https://numerics.mathdotnet.com/CSV.html">Delimited Text Files (CSV)</a></li>
<li><a href="https://numerics.mathdotnet.com/MatrixMarket.html">NIST MatrixMarket</a></li>
<li><a href="https://numerics.mathdotnet.com/MatlabFiles.html">MATLAB</a></li>
<li><a href="https://numerics.mathdotnet.com/IFSharpNotebook.html">IF# Notebook</a></li>
<li>FsLab & Deedle</li>
<li>Microsoft Excel</li>
<li>numl.net machine learning</li>
<li>R-project</li>
</ul>
</div>
</div>
</div>
</body>
</html>