/// <summary>
/// Initializes a new instance of the <see cref="UniformGenerator"/> class
/// </summary>
///
/// <param name="range">Random numbers range</param>
/// <param name="seed">Seed value to initialize random numbers generator</param>
///
public UniformGenerator( DoubleRange range, int seed )
{
rand = new UniformOneGenerator( seed );
min = range.Min;
length = range.Length;
}
public ActivationFunctionView()
{
this.plotSteps = 1;
this.plotDomain = new DoubleRange(-1, 1);
InitializeComponent();
CreateGraph(zedGraphControl);
}
public void ScaleTest2()
{
DoubleRange from = new DoubleRange(-100, 100);
DoubleRange to = new DoubleRange(0, 50);
double x = 0;
double expected = 25;
double actual = Tools.Scale(from, to, x);
Assert.AreEqual(expected, actual);
}
public void AddColor(HSL selectedColor,IntRange Hue_range, DoubleRange Saturation_range, DoubleRange Luminance_range)
{
TreeNode node = new TreeNode(new String(' ',100));
node.Tag = new LayerColor(selectedColor, Hue_range, Saturation_range, Luminance_range);
node.Checked = true;
new_color_parent.Nodes.Add(node);
new_color_parent.ExpandAll();
treeLayers.SelectedNode = node;
UpdateFilter();
}
public LayerColor(HSL _color, IntRange _hue_range, DoubleRange _sat_range, DoubleRange _lum_range)
{
color = _color;
hue_range = _hue_range;
sat_range = _sat_range;
lum_range = _lum_range;
RGB rgb = new RGB();
AForge.Imaging.ColorConverter.HSL2RGB(color, rgb);
RGBColor = rgb.Color;
}
/// <summary>
/// Creates a new <see cref="GeneralContinuousDistribution"/> with the given PDF and CDF functions.
/// </summary>
///
/// <param name="support">The distribution's support over the real line.</param>
/// <param name="density">A probability density function.</param>
/// <param name="distribution">A cumulative distribution function.</param>
///
public GeneralContinuousDistribution(DoubleRange support,
Func<double, double> density, Func<double, double> distribution)
{
if (density == null)
throw new ArgumentNullException("density");
if (distribution == null)
throw new ArgumentNullException("distribution");
this.pdf = density;
this.cdf = distribution;
this.support = support;
}
/// <summary>
/// Estimates suitable values for the sigmoid kernel
/// by exploring the response area of the tanh function.
/// </summary>
///
/// <param name="inputs">An input data set.</param>
/// <param name="samples">The size of the subset to use in the estimation.</param>
/// <param name="range">The interquartile range for the data.</param>
///
/// <returns>A Sigmoid kernel initialized with appropriate values.</returns>
///
public static Sigmoid Estimate(double[][] inputs, int samples, out DoubleRange range)
{
if (samples > inputs.Length)
throw new ArgumentOutOfRangeException("samples");
double[] distances = Products(inputs, samples);
double q1 = Math.Sqrt(distances[(int)Math.Ceiling(0.15 * distances.Length)] / 2.0);
double q9 = Math.Sqrt(distances[(int)Math.Ceiling(0.85 * distances.Length)] / 2.0);
double qm = Math.Sqrt(Accord.Statistics.Tools.Median(distances, alreadySorted: true) / 2.0);
range = new DoubleRange(q1, q9);
double max = qm;
double r = -Math.E;
double a = -r / max;
return new Sigmoid(a, r);
}
// Worker thread
void SearchSolution()
{
// number of learning samples
int samples = data.GetLength(0);
// prepare learning data
DoubleRange unit = new DoubleRange(-1, 1);
double[][] input = Tools.Scale(from: xRange, to: unit, x: data.GetColumn(0)).ToArray();
double[][] output = Tools.Scale(from: yRange, to: unit, x: data.GetColumn(1)).ToArray();
// create multi-layer neural network
ActivationNetwork network = new ActivationNetwork(
new BipolarSigmoidFunction(sigmoidAlphaValue),
1, neuronsInFirstLayer, 1);
if (useNguyenWidrow)
{
new NguyenWidrow(network).Randomize();
}
// create teacher
var teacher = new ParallelResilientBackpropagationLearning(network);
// iterations
int iteration = 1;
// solution array
double[,] solution = new double[samples, 2];
// loop
while (!needToStop)
{
// run epoch of learning procedure
double error = teacher.RunEpoch(input, output) / samples;
// calculate solution
for (int j = 0; j < samples; j++)
{
double x = input[j][0];
double y = network.Compute(new[] { x })[0];
solution[j, 0] = Tools.Scale(from: unit, to: xRange, x: x);
solution[j, 1] = Tools.Scale(from: unit, to: yRange, x: y);
}
chart.UpdateDataSeries("solution", solution);
// calculate error
double learningError = 0.0;
for (int j = 0; j < samples; j++)
{
double x = input[j][0];
double expected = data[j, 1];
double actual = network.Compute(new[] { x })[0];
learningError += Math.Abs(expected - actual);
}
// set current iteration's info
SetText(currentIterationBox, iteration.ToString());
SetText(currentErrorBox, learningError.ToString("F3"));
// increase current iteration
iteration++;
// check if we need to stop
if ((iterations != 0) && (iteration > iterations))
break;
}
// enable settings controls
EnableControls(true);
}
public bool IsInside(DoubleRange range)
{
return(this.IsInside(range.min) && this.IsInside(range.max));
}
// Load data
private void loadDataButton_Click(object sender, System.EventArgs e)
{
// show file selection dialog
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
data = null;
try
{
// open selected file
using (TextReader stream = new StreamReader(openFileDialog.FileName))
using (CsvReader reader = new CsvReader(stream, false))
{
data = reader.ToTable().ToMatrix(CultureInfo.InvariantCulture);
}
}
catch (Exception)
{
MessageBox.Show("Failed reading the file", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
DoubleRange[] ranges = data.Range(dimension: 0);
xRange = ranges[0];
yRange = ranges[1];
// update list and chart
UpdateDataListView();
chart.RangeX = new Range((float)ranges[0].Min, (float)ranges[0].Max);
chart.UpdateDataSeries("data", data);
chart.UpdateDataSeries("solution", null);
// enable "Start" button
startButton.Enabled = true;
}
}
/// <summary>
/// Paints the control.
/// </summary>
///
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
int clientWidth = ClientRectangle.Width;
int clientHeight = ClientRectangle.Height;
// fill with background
g.FillRectangle(backgroundBrush, 0, 0, clientWidth - 1, clientHeight - 1);
// draw borders
g.DrawRectangle(bordersPen, 0, 0, clientWidth - 1, clientHeight - 1);
if (DesignMode)
return;
DoubleRange rangeClientX = new DoubleRange(0, clientWidth);
DoubleRange rangeClientY = new DoubleRange(clientHeight, 0);
// walk through all data series
foreach (Waveform waveform in waveTable.Values)
{
// get data of the waveform
float[] data = waveform.data;
// check for available data
if (data == null) continue;
using (Pen pen = new Pen(waveform.color, waveform.width))
{
if (SimpleMode)
{
int blockSize = waveform.samples / clientWidth;
for (int x = 0; x < clientWidth; x++)
{
double max = data.RootMeanSquare(x * blockSize, blockSize);
int y = clientHeight / 2 + (int)(max * clientHeight);
g.DrawLine(pen, x, clientHeight - y, x, y);
}
}
else
{
int xPrev = 0;
int yPrev = (int)rangeY.Scale(rangeClientY, data[0]);
for (int x = 0; x < clientWidth; x++)
{
int index = (int)rangeClientX.Scale(rangeX, x);
if (index < 0 || index >= data.Length)
index = data.Length - 1;
int y = (int)rangeY.Scale(rangeClientY, data[index]);
g.DrawLine(pen, xPrev, yPrev, x, y);
xPrev = x;
yPrev = y;
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LinearFunction"/> class.
/// </summary>
///
public LinearFunction(DoubleRange range)
{
this.Range = range;
}
/// <summary>
/// Estimate appropriate values for sigma given a data set.
/// </summary>
///
/// <remarks>
/// This method uses a simple heuristic to obtain appropriate values
/// for sigma in a radial basis function kernel. The heuristic is shown
/// by Caputo, Sim, Furesjo and Smola, "Appearance-based object
/// recognition using SVMs: which kernel should I use?", 2002.
/// </remarks>
///
/// <param name="inputs">The data set.</param>
/// <param name="range">The range of suitable values for sigma.</param>
///
/// <returns>A Gaussian kernel initialized with an appropriate sigma value.</returns>
///
public static Gaussian Estimate(double[][] inputs, out DoubleRange range)
{
return Estimate(inputs, inputs.Length, out range);
}
/// <summary>
/// Gets the 95% confidence interval for the
/// Hazard Ratio for a given coefficient.
/// </summary>
///
/// <param name="index">
/// The coefficient's index.
/// </param>
///
public DoubleRange GetConfidenceInterval(int index)
{
double coeff = Coefficients[index];
double error = StandardErrors[index];
double upper = coeff + 1.9599 * error;
double lower = coeff - 1.9599 * error;
DoubleRange ci = new DoubleRange(Math.Exp(lower), Math.Exp(upper));
return ci;
}
/// <summary>
/// Creates a new <see cref="GeneralContinuousDistribution"/>
/// using only a cumulative distribution function definition.
/// </summary>
///
/// <param name="support">The distribution's support over the real line.</param>
/// <param name="cdf">A cumulative distribution function.</param>
/// <param name="method">The integration method to use for numerical computations.</param>
///
/// <returns>A <see cref="GeneralContinuousDistribution"/> created from the
/// <paramref name="cdf"/> whose measures and functions are computed using
/// numerical integration and differentiation.</returns>
///
public static GeneralContinuousDistribution FromDistributionFunction(
DoubleRange support, Func<double, double> cdf, IUnivariateIntegration method)
{
GeneralContinuousDistribution dist = new GeneralContinuousDistribution();
dist.support = support;
dist.cdf = cdf;
dist.method = method;
return dist;
}
/// <summary>
/// Creates a new <see cref="GeneralContinuousDistribution"/>
/// using only a cumulative distribution function definition.
/// </summary>
///
/// <param name="cdf">A cumulative distribution function.</param>
///
/// <returns>A <see cref="GeneralContinuousDistribution"/> created from the
/// <paramref name="cdf"/> whose measures and functions are computed using
/// numerical integration and differentiation.</returns>
///
public static GeneralContinuousDistribution FromDistributionFunction(Func<double, double> cdf)
{
var range = new DoubleRange(double.NegativeInfinity, double.PositiveInfinity);
var method = createDefaultIntegrationMethod();
return FromDistributionFunction(range, cdf, method);
}
public void MeshTest()
{
DoubleRange rowRange = new DoubleRange(-1, 1);
DoubleRange colRange = new DoubleRange(-1, 1);
double rowSteps = 0.5f;
double colSteps = 0.5f;
double[][] expected =
{
new double[] { -1.0, -1.0 },
new double[] { -1.0, -0.5 },
new double[] { -1.0, 0.0 },
new double[] { -1.0, 0.5 },
new double[] { -1.0, 1.0 },
new double[] { -0.5, -1.0 },
new double[] { -0.5, -0.5 },
new double[] { -0.5, 0.0 },
new double[] { -0.5, 0.5 },
new double[] { -0.5, 1.0 },
new double[] { 0.0, -1.0 },
new double[] { 0.0, -0.5 },
new double[] { 0.0, 0.0 },
new double[] { 0.0, 0.5 },
new double[] { 0.0, 1.0 },
new double[] { 0.5, -1.0 },
new double[] { 0.5, -0.5 },
new double[] { 0.5, 0.0 },
new double[] { 0.5, 0.5 },
new double[] { 0.5, 1.0 },
new double[] { 1.0, -1.0 },
new double[] { 1.0, -0.5 },
new double[] { 1.0, 0.0 },
new double[] { 1.0, 0.5 },
new double[] { 1.0, 1.0 },
};
double[][] actual = Matrix.Mesh(rowRange, colRange, rowSteps, colSteps);
Assert.IsTrue(expected.IsEqual(actual));
}
/// <summary>
/// Check if the specified range is inside of the range.
/// </summary>
///
/// <param name="range">Range to check.</param>
///
/// <returns><b>True</b> if the specified range is inside of the range or
/// <b>false</b> otherwise.</returns>
///
public bool IsInside(DoubleRange range)
{
return((IsInside(range.min)) && (IsInside(range.max)));
}
/// <summary>
/// Check if the specified range overlaps with the range.
/// </summary>
///
/// <param name="range">Range to check for overlapping.</param>
///
/// <returns><b>True</b> if the specified range overlaps with the range or
/// <b>false</b> otherwise.</returns>
///
public bool IsOverlapping(DoubleRange range)
{
return((IsInside(range.min)) || (IsInside(range.max)) ||
(range.IsInside(min)) || (range.IsInside(max)));
}
/// <summary>
/// Creates a new <see cref="GeneralContinuousDistribution"/> with the given PDF and CDF functions.
/// </summary>
///
/// <param name="support">The distribution's support over the real line.</param>
/// <param name="density">A probability density function.</param>
/// <param name="distribution">A cumulative distribution function.</param>
///
public GeneralContinuousDistribution(DoubleRange support,
Func<double, double> density, Func<double, double> distribution)
{
if (density == null)
throw new ArgumentNullException("density");
if (distribution == null)
throw new ArgumentNullException("distribution");
this.method = new InfiniteAdaptiveGaussKronrod(100);
this.pdf = density;
this.cdf = distribution;
this.support = support;
}
/// <summary>
/// Computes the circular quartiles of the given circular angles.
/// </summary>
///
/// <param name="angles">A double array containing the angles in radians.</param>
/// <param name="range">The sample quartiles, as an out parameter.</param>
/// <param name="median">The angular median, if already known.</param>
/// <param name="wrap">
/// Whether range values should be wrapped to be contained in the circle. If
/// set to false, range values could be returned outside the [+pi;-pi] range.
/// </param>
///
/// <returns>The median of the given angles.</returns>
///
public static double Quartiles(double[] angles, out DoubleRange range, double median, bool wrap = true)
{
double q1, q3;
double q2 = Quartiles(angles, out q1, out q3, median, wrap);
System.Diagnostics.Debug.Assert(q2 == median);
range = new DoubleRange(q1, q3);
return median;
}
/// <summary>
/// Creates a new <see cref="GeneralContinuousDistribution"/>
/// using only a cumulative distribution function definition.
/// </summary>
///
/// <param name="support">The distribution's support over the real line.</param>
/// <param name="cdf">A cumulative distribution function.</param>
///
/// <returns>A <see cref="GeneralContinuousDistribution"/> created from the
/// <paramref name="cdf"/> whose measures and functions are computed using
/// numerical integration and differentiation.</returns>
///
public static GeneralContinuousDistribution FromDistributionFunction(
DoubleRange support, Func<double, double> cdf)
{
var method = createDefaultIntegrationMethod();
return FromDistributionFunction(support, cdf, method);
}
/// <summary>
/// Update Y range.
/// </summary>
private void UpdateYRange( )
{
double minY = double.MaxValue;
double maxY = double.MinValue;
// walk through all data series
IDictionaryEnumerator en = seriesTable.GetEnumerator( );
while ( en.MoveNext( ) )
{
DataSeries series = (DataSeries) en.Value;
// get data of the series
double[,] data = series.data;
if ( ( series.updateYRange ) && ( data != null ) )
{
for ( int i = 0, n = data.GetLength( 0 ); i < n; i++ )
{
double v = data[i, 1];
// check for max
if ( v > maxY )
maxY = v;
// check for min
if ( v < minY )
minY = v;
}
}
}
// update Y range, if there are any data
if ( ( minY != double.MaxValue ) || ( maxY != double.MinValue ) )
{
rangeY = new DoubleRange( minY, maxY );
}
}
/// <summary>
/// Initializes a new instance of the <see cref="KCurvature"/> class.
/// </summary>
/// <param name="k">The number K of previous and posterior
/// points to consider when find local extremum points.</param>
/// <param name="theta">The theta angle range (in
/// degrees) used to define extremum points..</param>
public KCurvature(int k, DoubleRange theta)
{
this.K = k;
this.Theta = theta;
this.Suppression = k;
}
/// <summary>
/// Check if the specified range is inside of the range.
/// </summary>
///
/// <param name="range">Range to check.</param>
///
/// <returns><b>True</b> if the specified range is inside of the range or
/// <b>false</b> otherwise.</returns>
///
public bool IsInside( DoubleRange range )
{
return ( ( IsInside( range.min ) ) && ( IsInside( range.max ) ) );
}
public static double ConvertRange(int value, DoubleRange from, DoubleRange to)
{
return ((value - from.Min) * (to.Length) / (from.Length)) + to.Min;
}
/// <summary>
/// Check if the specified range overlaps with the range.
/// </summary>
///
/// <param name="range">Range to check for overlapping.</param>
///
/// <returns><b>True</b> if the specified range overlaps with the range or
/// <b>false</b> otherwise.</returns>
///
public bool IsOverlapping( DoubleRange range )
{
return ( ( IsInside( range.min ) ) || ( IsInside( range.max ) ) ||
( range.IsInside( min ) ) || ( range.IsInside( max ) ) );
}
/// <summary>
/// Estimate appropriate values for sigma given a data set.
/// </summary>
///
/// <remarks>
/// This method uses a simple heuristic to obtain appropriate values
/// for sigma in a radial basis function kernel. The heuristic is shown
/// by Caputo, Sim, Furesjo and Smola, "Appearance-based object
/// recognition using SVMs: which kernel should I use?", 2002.
/// </remarks>
///
/// <param name="inputs">The data set.</param>
/// <param name="samples">The number of random samples to analyze.</param>
/// <param name="range">The range of suitable values for sigma.</param>
///
/// <returns>A Laplacian kernel initialized with an appropriate sigma value.</returns>
///
public static Laplacian Estimate(double[][] inputs, int samples, out DoubleRange range)
{
if (samples > inputs.Length)
throw new ArgumentOutOfRangeException("samples");
double[] distances = Gaussian.Distances(inputs, samples);
double q1 = distances[(int)Math.Ceiling(0.15 * distances.Length)];
double q9 = distances[(int)Math.Ceiling(0.85 * distances.Length)];
double qm = Accord.Statistics.Tools.Median(distances, alreadySorted: true);
range = new DoubleRange(q1, q9);
return new Laplacian(sigma: qm);
}
/// <summary>
/// Constructs a new <see cref="RombergMethod">Romberg's integration method</see>.
/// </summary>
///
/// <param name="steps">The number of steps used in Romberg's method. Default is 6.</param>
///
public RombergMethod(int steps)
{
this.s = new double[steps];
Range = new DoubleRange(0, 1);
}
/// <summary>
/// Update Y range.
/// </summary>
///
private void UpdateYRange()
{
float minY = float.MaxValue;
float maxY = float.MinValue;
// walk through all data series
foreach (Waveform wave in waveTable.Values)
{
// get data of the series
float[] data = wave.data;
if ((wave.updateYRange) && (data != null))
{
// Let the compiler perform optimizations.
for (int i = 0; i < data.Length; i++)
{
if (data[i] > maxY)
maxY = data[i];
if (data[i] < minY)
minY = data[i];
}
}
}
// update Y range, if there are any data
if ((minY != float.MaxValue) || (maxY != float.MinValue))
{
rangeY = new DoubleRange(minY, maxY);
}
}
/// <summary>
/// Constructs a new <see cref="RombergMethod">Romberg's integration method</see>.
/// </summary>
///
/// <param name="steps">The number of steps used in Romberg's method. Default is 6.</param>
/// <param name="function">The unidimensional function whose integral should be computed.</param>
///
public RombergMethod(int steps, Func<double, double> function)
{
if (function == null)
throw new ArgumentNullException("function");
Range = new DoubleRange(0, 1);
Function = function;
this.s = new double[steps];
}
/// <summary>
/// Initializes a new instance of the <see cref="LinearFunction"/> class.
/// </summary>
///
public LinearFunction(double alpha, DoubleRange range)
{
this.Alpha = alpha;
this.Range = range;
}
/// <summary>
/// Constructs a new <see cref="RombergMethod">Romberg's integration method</see>.
/// </summary>
///
/// <param name="steps">The number of steps used in Romberg's method. Default is 6.</param>
/// <param name="function">The unidimensional function whose integral should be computed.</param>
/// <param name="a">The beginning of the integration interval.</param>
/// <param name="b">The ending of the integration interval.</param>
///
public RombergMethod(int steps, Func<double, double> function, double a, double b)
{
if (Double.IsInfinity(a) || Double.IsNaN(a))
throw new ArgumentOutOfRangeException("a");
if (Double.IsInfinity(b) || Double.IsNaN(b))
throw new ArgumentOutOfRangeException("b");
Function = function;
Range = new DoubleRange(a, b);
this.s = new double[steps];
}