public void MedianOfSorted() { // Empty array. var arr = Array.Empty <float>(); Assert.Throws <ArgumentException>(() => MathSpan.MedianOfSorted(arr)); // Single element. arr = new float[] { 5 }; double actual = MathSpan.MedianOfSorted(arr); Assert.Equal(5, actual); // Two elements. arr = new float[] { 2, 4 }; actual = MathSpan.MedianOfSorted(arr); Assert.Equal(3.0, actual); // Three elements. arr = new float[] { 1, 2, 3 }; actual = MathSpan.MedianOfSorted(arr); Assert.Equal(2, actual); // Five elements. arr = new float[] { 1, 2, 3, 4, 5 }; actual = MathSpan.MedianOfSorted(arr); Assert.Equal(3, actual); // Six elements. arr = new float[] { 1, 2, 3, 4, 5, 6 }; actual = MathSpan.MedianOfSorted(arr); Assert.Equal(3.5, actual); }
/// <summary> /// Evaluate the provided black box against the function regression task, /// and return its fitness score. /// </summary> /// <param name="box">The black box to evaluate.</param> /// <returns>A new instance of <see cref="FitnessInfo"/>.</returns> public FitnessInfo Evaluate(IBlackBox <double> box) { // Probe the black box over the full range of the input parameter. _blackBoxProbe.Probe(box, _yArr); // Calc gradients. FuncRegressionUtils.CalcGradients(_paramSamplingInfo, _yArr, _gradientArr); // Calc y position mean squared error (MSE), and apply weighting. double yMse = MathSpan.MeanSquaredDelta(_yArr, _yArrTarget); yMse *= _yMseWeight; // Calc gradient mean squared error. double gradientMse = MathSpan.MeanSquaredDelta(_gradientArr, _gradientArrTarget); gradientMse *= _gradientMseWeight; // Calc fitness as the inverse of MSE (higher value is fitter). // Add a constant to avoid divide by zero, and to constrain the fitness range between bad and good solutions; // this allows the selection strategy to select solutions that are mediocre and therefore helps preserve diversity. double fitness = 20.0 / (yMse + gradientMse + 0.02); return(new FitnessInfo(fitness)); }
private static void Max_Inner(UniformDistributionSampler sampler, int len) { // Alloc arrays and fill with uniform random noise. float[] a = new float[len]; sampler.Sample(a); // Calc results and compare. float expected = PointwiseMax(a); float actual = MathSpan.Max(a); Assert.Equal(expected, actual); }
private static void Min_Inner(UniformDistributionSampler sampler, int len) { // Alloc arrays and fill with uniform random noise. double[] a = new double[len]; sampler.Sample(a); // Calc results and compare. double expected = PointwiseMin(a); double actual = MathSpan.Min(a); Assert.Equal(expected, actual); }
private static void Max_Inner(ISampler <int> sampler, int len) { // Alloc arrays and fill with uniform random noise. int[] a = new int[len]; sampler.Sample(a); // Calc results and compare. int expected = PointwiseMax(a); int actual = MathSpan.Max(a); Assert.Equal(expected, actual); }
private static void SumOfSquares_Inner(UniformDistributionSampler sampler, int len) { // Alloc array and fill with uniform random noise. float[] x = new float[len]; sampler.Sample(x); // Sum the array elements. float expected = PointwiseSumOfSquares(x); float actual = MathSpan.SumOfSquares(x); // Compare expected and actual sum. Assert.Equal(expected, actual, 3); }
private static void Sum_Inner(UniformDistributionSampler sampler, int len) { // Alloc array and fill with uniform random noise. double[] x = new double[len]; sampler.Sample(x); // Sum the array elements. double expected = PointwiseSum(x); double actual = MathSpan.Sum(x); // Compare expected and actual sum. Assert.Equal(expected, actual, 12); }
private static void MinMax_Inner(UniformDistributionSampler sampler, int len) { // Alloc arrays and fill with uniform random noise. double[] a = new double[len]; sampler.Sample(a); // Calc results and compare. PointwiseMinMax(a, out double expectedMin, out double expectedMax); MathSpan.MinMax(a, out double actualMin, out double actualMax); Assert.Equal(expectedMin, actualMin, 10); Assert.Equal(expectedMax, actualMax, 10); }
private static void Sum_Inner(ISampler <int> sampler, int len) { // Alloc array and fill with uniform random noise. int[] x = new int[len]; sampler.Sample(x); // Sum the array elements. int expected = PointwiseSum(x); int actual = MathSpan.Sum(x); // Compare expected and actual sum. Assert.Equal(expected, actual); }
private static void MeanSquaredDelta_Inner(UniformDistributionSampler sampler, int len) { // Alloc arrays and fill with uniform random noise. float[] a = new float[len]; float[] b = new float[len]; sampler.Sample(a); sampler.Sample(b); // Calc results and compare. float expected = PointwiseSumSquaredDelta(a, b) / a.Length; float actual = MathSpan.MeanSquaredDelta(a, b); Assert.Equal(expected, actual, 3); }
private static void Clip_Inner(UniformDistributionSampler sampler, int len) { // Alloc array and fill with uniform random noise. float[] x = new float[len]; sampler.Sample(x); // Clip the elements of the array with the safe routine. float[] expected = (float[])x.Clone(); PointwiseClip(expected, -1.1f, 18.8f); // Clip the elements of the array. float[] actual = (float[])x.Clone(); MathSpan.Clip(actual, -1.1f, 18.8f); // Compare expected with actual array. Assert.True(SpanUtils.Equal <float>(expected, actual)); }
private static void Clip_Inner(ISampler <int> sampler, int len) { // Alloc array and fill with uniform random noise. int[] x = new int[len]; sampler.Sample(x); // Clip the elements of the array with the safe routine. int[] expected = (int[])x.Clone(); PointwiseClip(expected, -1, 18); // Clip the elements of the array. int[] actual = (int[])x.Clone(); MathSpan.Clip(actual, -1, 18); // Compare expected with actual array. Assert.True(SpanUtils.Equal <int>(expected, actual)); }
private static LightweightList <int>[] BuildNodesByLayer(DirectedGraph digraph) { // Build an array that gives the node layer for each node, keyed by node index. int[] nodeLayerByIdx = BuildNodeLayerByIdx(digraph); // Group nodes into layers. int layerCount = MathSpan.Max(nodeLayerByIdx) + 1; var nodesByLayer = new LightweightList <int> [layerCount]; for (int i = 0; i < layerCount; i++) { nodesByLayer[i] = new LightweightList <int>(); } for (int nodeIdx = 0; nodeIdx < nodeLayerByIdx.Length; nodeIdx++) { int depth = nodeLayerByIdx[nodeIdx]; nodesByLayer[depth].Add(nodeIdx); } return(nodesByLayer); }
/// <summary> /// Calculate a histogram for the provided span of values. /// 1) The minimum and maximum values are found. /// 2) The resulting value range is divided into equal sized sub-ranges or bins. /// 3) The number of values that fall into each bin is determined. /// </summary> /// <param name="vals">The values to calculate a histogram for.</param> /// <param name="binCount">The number of histogram bins to use.</param> /// <returns>A new instance of <see cref="HistogramData"/>.</returns> public static HistogramData BuildHistogramData(Span <double> vals, int binCount) { // Determine min/max. MathSpan.MinMax(vals, out double min, out double max); // Note. each bin's range has interval [low,high), i.e. samples exactly equal to 'high' will fall // into the next highest bin. Except for the last bin which has interval [low, high]. double range = max - min; // Handle special case where the data series contains a single value. if (range == 0.0) { return(new HistogramData(min, max, 0.0, new int[] { vals.Length })); } // Loop values, and for each one increment the relevant category's frequency count. double incr = range / binCount; int[] frequencyArr = new int[binCount]; for (int i = 0; i < vals.Length; i++) { // Determine which bin the value falls within. int binIdx = (int)((vals[i] - min) / incr); // Values that equal max, are placed into the last bin. if (binIdx == binCount) { binIdx--; } frequencyArr[binIdx]++; } return(new HistogramData(min, max, incr, frequencyArr)); }