diff --git a/src/MathNet.Numerics.4.5.resharper b/src/MathNet.Numerics.4.5.resharper
index d6c48cd3..73833a90 100644
--- a/src/MathNet.Numerics.4.5.resharper
+++ b/src/MathNet.Numerics.4.5.resharper
@@ -13,7 +13,7 @@
Wikipedia
Cholesky
Bluestein
-
+Chebyshev
@@ -33,7 +33,7 @@ Bluestein
false
- 80
+ 120
@@ -790,7 +790,9 @@ Bluestein
CHOP_ALWAYS
CHOP_IF_LONG
-
+
+ True
+
diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj
index d976fe73..77ecedee 100644
--- a/src/Numerics/Numerics.csproj
+++ b/src/Numerics/Numerics.csproj
@@ -96,6 +96,8 @@
True
Resources.resx
+
+
diff --git a/src/Numerics/Sampling/Sample.Chebyshev.cs b/src/Numerics/Sampling/Sample.Chebyshev.cs
new file mode 100644
index 00000000..26ab1363
--- /dev/null
+++ b/src/Numerics/Sampling/Sample.Chebyshev.cs
@@ -0,0 +1,126 @@
+//
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// Copyright (c) 2009 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+
+namespace MathNet.Numerics.Sampling
+{
+ using System;
+
+ ///
+ /// Generic Function Sampling and Quantization Provider
+ ///
+ public static partial class Sample
+ {
+ ///
+ /// Samples a function at the roots of the Chebyshev polynomial of the first kind.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain interval begin where to start sampling.
+ /// The real domain interval end where to stop sampling.
+ /// The number of samples to generate.
+ /// The value type of the function to sample.
+ /// Vector of the function sampled in [a,b] at (b+a)/2+(b-1)/2*cos(pi*(2i-1)/(2n))
+ ///
+ ///
+ public static T[] ChebyshevNodesFirstKind(
+ Func function,
+ double intervalBegin,
+ double intervalEnd,
+ int sampleCount)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 1)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ // transform to map to [-1..1] interval
+ double transformSummand = 0.5 * (intervalBegin + intervalEnd);
+ double transformFactor = 0.5 * (intervalEnd - intervalBegin);
+
+ // evaluate first kind chebyshev nodes
+ double angleFactor = Constants.Pi / (2 * sampleCount);
+
+ var samples = new T[sampleCount];
+
+ for (int i = 0; i < samples.Length; i++)
+ {
+ samples[i] = function(transformSummand + transformFactor * Math.Cos(((2 * i) + 1) * angleFactor));
+ }
+
+ return samples;
+ }
+
+ ///
+ /// Samples a function at the roots of the Chebyshev polynomial of the second kind.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain interval begin where to start sampling.
+ /// The real domain interval end where to stop sampling.
+ /// The number of samples to generate.
+ /// The value type of the function to sample.
+ /// Vector of the function sampled in [a,b] at (b+a)/2+(b-1)/2*cos(pi*i/(n-1))
+ ///
+ ///
+ public static T[] ChebyshevNodesSecondKind(
+ Func function,
+ double intervalBegin,
+ double intervalEnd,
+ int sampleCount)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 1)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ // transform to map to [-1..1] interval
+ double transformSummand = 0.5 * (intervalBegin + intervalEnd);
+ double transformFactor = 0.5 * (intervalEnd - intervalBegin);
+
+ // evaluate second kind chebyshev nodes
+ double angleFactor = Constants.Pi / (sampleCount + 1);
+
+ var samples = new T[sampleCount];
+
+ for (int i = 0; i < samples.Length; i++)
+ {
+ samples[i] = function(transformSummand + transformFactor * Math.Cos((i + 1) * angleFactor));
+ }
+
+ return samples;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Numerics/Sampling/Sample.Equidistant.cs b/src/Numerics/Sampling/Sample.Equidistant.cs
new file mode 100644
index 00000000..58b30594
--- /dev/null
+++ b/src/Numerics/Sampling/Sample.Equidistant.cs
@@ -0,0 +1,368 @@
+//
+// Math.NET Numerics, part of the Math.NET Project
+// http://mathnet.opensourcedotnet.info
+//
+// Copyright (c) 2009 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+
+namespace MathNet.Numerics.Sampling
+{
+ using System;
+ using System.Collections.Generic;
+
+ ///
+ /// Generic Function Sampling and Quantization Provider
+ ///
+ public static partial class Sample
+ {
+ ///
+ /// Samples a function equidistant within the provided interval.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain interval begin where to start sampling.
+ /// The real domain interval end where to stop sampling.
+ /// The number of samples to generate.
+ /// The value type of the function to sample.
+ /// The generated sample vector.
+ ///
+ ///
+ public static T[] EquidistantInterval(
+ Func function,
+ double intervalBegin,
+ double intervalEnd,
+ int sampleCount)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 0)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ if (sampleCount == 0)
+ {
+ return new T[0];
+ }
+
+ if (sampleCount == 1)
+ {
+ return new T[] { function(0.5 * (intervalBegin + intervalEnd)) };
+ }
+
+ var samples = new T[sampleCount];
+ var step = (intervalEnd - intervalBegin) / (sampleCount - 1);
+ var current = intervalBegin;
+
+ for (int i = 0; i < samples.Length - 1; i++)
+ {
+ samples[i] = function(current);
+ current += step;
+ }
+
+ samples[samples.Length - 1] = function(intervalEnd);
+
+ return samples;
+ }
+
+ ///
+ /// Samples a function equidistant within the provided interval.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain interval begin where to start sampling.
+ /// The real domain interval end where to stop sampling.
+ /// The number of samples to generate.
+ /// The real domain points where the samples are taken at.
+ /// The value type of the function to sample.
+ /// The generated sample vector.
+ ///
+ ///
+ public static T[] EquidistantInterval(
+ Func function,
+ double intervalBegin,
+ double intervalEnd,
+ int sampleCount,
+ out double[] samplePoints)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 0)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ if (sampleCount == 0)
+ {
+ samplePoints = new double[0];
+ return new T[0];
+ }
+
+ if (sampleCount == 1)
+ {
+ samplePoints = new[] { 0.5 * (intervalBegin + intervalEnd) };
+ return new T[] { function(samplePoints[0]) };
+ }
+
+ var samples = new T[sampleCount];
+ samplePoints = new double[sampleCount];
+ var step = (intervalEnd - intervalBegin) / (sampleCount - 1);
+ var current = intervalBegin;
+
+ for (int i = 0; i < samples.Length - 1; i++)
+ {
+ samplePoints[i] = current;
+ samples[i] = function(current);
+ current += step;
+ }
+
+ samplePoints[samplePoints.Length - 1] = intervalEnd;
+ samples[samples.Length - 1] = function(intervalEnd);
+
+ return samples;
+ }
+
+ ///
+ /// Samples a periodic function equidistant within one period, but omits the last sample such that the sequence
+ /// can be concatenated together.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain full period length.
+ /// The real domain offset where to start the sampling period.
+ /// The number of samples to generate.
+ /// The value type of the function to sample.
+ /// The generated sample vector.
+ ///
+ ///
+ public static T[] EquidistantPeriodic(
+ Func function,
+ double periodLength,
+ double periodOffset,
+ int sampleCount)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 1)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ var samples = new T[sampleCount];
+ var step = periodLength / sampleCount;
+ var current = periodOffset;
+
+ for (int i = 0; i < samples.Length; i++)
+ {
+ samples[i] = function(current);
+ current += step;
+ }
+
+ return samples;
+ }
+
+ ///
+ /// Samples a periodic function equidistant within one period, but omits the last sample such that the sequence
+ /// can be concatenated together.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain full period length.
+ /// The real domain offset where to start the sampling period.
+ /// The number of samples to generate.
+ /// The real domain points where the samples are taken at.
+ /// The value type of the function to sample.
+ /// The generated sample vector.
+ ///
+ ///
+ public static T[] EquidistantPeriodic(
+ Func function,
+ double periodLength,
+ double periodOffset,
+ int sampleCount,
+ out double[] samplePoints)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 1)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ var samples = new T[sampleCount];
+ samplePoints = new double[sampleCount];
+ var step = periodLength / sampleCount;
+ var current = periodOffset;
+
+ for (int i = 0; i < samples.Length; i++)
+ {
+ samplePoints[i] = current;
+ samples[i] = function(current);
+ current += step;
+ }
+
+ return samples;
+ }
+
+ ///
+ /// Samples a function equidistant starting from the provided location with a fixed step length.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain location offset where to start sampling.
+ /// The real domain step length between the equidistant samples.
+ /// The number of samples to generate.
+ /// The value type of the function to sample.
+ /// The generated sample vector.
+ ///
+ ///
+ public static T[] EquidistantStartingAt(
+ Func function,
+ double start,
+ double step,
+ int sampleCount)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 0)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ var samples = new T[sampleCount];
+ var current = start;
+
+ for (int i = 0; i < samples.Length; i++)
+ {
+ samples[i] = function(current);
+ current += step;
+ }
+
+ return samples;
+ }
+
+ ///
+ /// Samples a function equidistant starting from the provided location with a fixed step length.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain location offset where to start sampling.
+ /// The real domain step length between the equidistant samples.
+ /// The number of samples to generate.
+ /// The real domain points where the samples are taken at.
+ /// The value type of the function to sample.
+ /// The generated sample vector.
+ ///
+ ///
+ public static T[] EquidistantStartingAt(
+ Func function,
+ double start,
+ double step,
+ int sampleCount,
+ out double[] samplePoints)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ if (sampleCount < 0)
+ {
+ throw new ArgumentOutOfRangeException("sampleCount");
+ }
+
+ var samples = new T[sampleCount];
+ samplePoints = new double[sampleCount];
+ var current = start;
+
+ for (int i = 0; i < samples.Length; i++)
+ {
+ samplePoints[i] = current;
+ samples[i] = function(current);
+ current += step;
+ }
+
+ return samples;
+ }
+
+ ///
+ /// Samples a function equidistant continuously starting from the provided location with a fixed step length.
+ ///
+ /// The real-domain function to sample.
+ /// The real domain location offset where to start sampling.
+ /// The real domain step length between the equidistant samples.
+ /// The value type of the function to sample.
+ /// The generated sample enumerator.
+ ///
+ public static IEnumerable EquidistantContinuous(
+ Func function,
+ double start,
+ double step)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ var current = start;
+
+ while (true)
+ {
+ yield return function(current);
+ current += step;
+ }
+ }
+
+ ///
+ /// Samples a function equidistant with the provided start and step length to an integer-domain function
+ ///
+ /// The real-domain function to sample.
+ /// The real domain location where to start sampling.
+ /// The real domain step length between the equidistant samples.
+ /// The value type of the function to sample.
+ /// The generated samples integer-domain function.
+ ///
+ public static Func EquidistantToFunction(
+ Func function,
+ double start,
+ double step)
+ {
+ if (ReferenceEquals(function, null))
+ {
+ throw new ArgumentNullException("function");
+ }
+
+ return k => function(start + k * step);
+ }
+ }
+}
\ No newline at end of file