/// <summary> /// Samples a two-domain function randomly with the provided distribution. /// </summary> /// <param name="function">The real-domain function to sample.</param> /// <param name="distribution">Random distribution of the real domain sample points.</param> /// <param name="sampleCount">The number of samples to generate.</param> /// <typeparam name="T">The value type of the function to sample.</typeparam> /// <returns>The generated sample vector.</returns> /// <exception cref="ArgumentNullException" /> /// <exception cref="ArgumentOutOfRangeException" /> public static T[] Random <T>( Func <double, double, T> function, IContinuousDistribution distribution, int sampleCount) { if (ReferenceEquals(function, null)) { throw new ArgumentNullException("function"); } if (ReferenceEquals(distribution, null)) { throw new ArgumentNullException("distribution"); } if (sampleCount < 0) { throw new ArgumentOutOfRangeException("sampleCount"); } var samples = new T[sampleCount]; for (int i = 0; i < samples.Length; i++) { samples[i] = function(distribution.Sample(), distribution.Sample()); } return(samples); }
/// <summary> /// Generate samples by sampling a function at sample pairs from a probability distribution. /// </summary> public static T[] RandomMap2 <T>(int length, IContinuousDistribution distribution, Func <double, double, T> map) { var data = new T[length]; for (int i = 0; i < data.Length; i++) { data[i] = map(distribution.Sample(), distribution.Sample()); } return(data); }
/// <summary> /// Samples a two-domain function randomly with the provided distribution. /// </summary> /// <param name="function">The real-domain function to sample.</param> /// <param name="distribution">Random distribution of the real domain sample points.</param> /// <param name="sampleCount">The number of samples to generate.</param> /// <typeparam name="T">The value type of the function to sample.</typeparam> /// <returns>The generated sample vector.</returns> /// <exception cref="ArgumentNullException" /> /// <exception cref="ArgumentOutOfRangeException" /> public static T[] Random <T>(Func <double, double, T> function, IContinuousDistribution distribution, int sampleCount) { function.ShouldNotBeNull("function"); distribution.ShouldNotBeNull("distribution"); sampleCount.ShouldBePositiveOrZero("sampleCount"); return (Enumerable .Range(0, sampleCount) .AsParallel() .AsOrdered() .Select(i => function(distribution.Sample(), distribution.Sample())) .ToArray()); }
/// <summary> /// Generates a vector with random elements /// </summary> /// <param name="length">Number of elements in the vector.</param> /// <param name="randomDistribution">Continuous Random Distribution or Source</param> /// <returns> /// A vector with n-random elements distributed according /// to the specified random distribution. /// </returns> /// <exception cref="ArgumentException">If the n vector is non-positive.</exception> public override Vector <Complex> Random(int length, IContinuousDistribution randomDistribution) { if (length < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "length"); } var vector = CreateVector(length); for (var index = 0; index < length; index++) { vector.At(index, new Complex(randomDistribution.Sample(), randomDistribution.Sample())); } return(vector); }
public static IEnumerable <double> LatinHyperCubeSample(this IContinuousDistribution ContinuousDistribution, int divisions) { for (int i = 0; i < divisions; i++) { yield return(ContinuousDistribution.Sample()); } }
public static List<PatternClass> Create2DimTeachingVectors(double p1, double p2, IContinuousDistribution generatorFirstFeature1, IContinuousDistribution generatorFirstFeature2, IContinuousDistribution generatorSecondFeature1, IContinuousDistribution generatorSecondFeature2, int nrOfTeachingVectors) { List<PatternClass> createdTeachingVectors = new List<PatternClass>(); if (probabilityGenerator == null) { probabilityGenerator = new ContinuousUniform(0, 1); probabilityGenerator.RandomSource = new Random(DateTime.Now.Millisecond + 10); } for (int i = 0; i < nrOfTeachingVectors; i++) { double value = 0; double value1 = 0; int classNumber = CreateClass(p1, p2); if (classNumber == 1) { value = generatorFirstFeature1.Sample(); value1 = generatorSecondFeature1.Sample(); } else if (classNumber == 2) { value = generatorFirstFeature2.Sample(); value1 = generatorSecondFeature2.Sample(); } createdTeachingVectors.Add(new PatternClass(new FeatureVector(value,value1), classNumber)); } return createdTeachingVectors; }
/// <summary> /// Create a new child genome from a given parent genome. /// </summary> /// <param name="parent">The parent genome.</param> /// <returns>A new child genome.</returns> public NeatGenome <T> CreateChildGenome(NeatGenome <T> parent) { Debug.Assert(_metaNeatGenome == parent.MetaNeatGenome, "Parent genome has unexpected MetaNeatGenome."); // Attempt to find a new connection that we can add to the genome. DirectedConnection directedConn; if (!TryGetConnection(parent, out directedConn, out int insertIdx)) { // Failed to find a new connection. return(null); } // Determine the connection weight. // 50% of the time use weights very close to zero. // Note. this recreates the strategy used in SharpNEAT 2.x. // ENHANCEMENT: Reconsider the distribution of new weights and if there are better approaches (distributions) we could use. T weight = _rng.NextBool() ? _weightDistB.Sample() : _weightDistA.Sample(); // Create a new connection gene array that consists of the parent connection genes plus the new gene // inserted at the correct (sorted) position. var parentConnArr = parent.ConnectionGenes._connArr; var parentWeightArr = parent.ConnectionGenes._weightArr; int parentLen = parentConnArr.Length; // Create the child genome's ConnectionGenes object. int childLen = parentLen + 1; var connGenes = new ConnectionGenes <T>(childLen); var connArr = connGenes._connArr; var weightArr = connGenes._weightArr; // Copy genes up to insertIdx. Array.Copy(parentConnArr, connArr, insertIdx); Array.Copy(parentWeightArr, weightArr, insertIdx); // Copy the new genome into its insertion point. connArr[insertIdx] = new DirectedConnection( directedConn.SourceId, directedConn.TargetId); weightArr[insertIdx] = weight; // Copy remaining genes (if any). Array.Copy(parentConnArr, insertIdx, connArr, insertIdx + 1, parentLen - insertIdx); Array.Copy(parentWeightArr, insertIdx, weightArr, insertIdx + 1, parentLen - insertIdx); // Create and return a new genome. // Notes. // The set of hidden node IDs remains unchanged from the parent, therefore we are able to re-use parent.HiddenNodeIdArray. // However, the presence of a new connection invalidates parent.NodeIndexByIdMap for use in the new genome, because the allocated // node indexes are dependent on node depth in the acyclic graph, which in turn can be modified by the presence of a new connection. return(_genomeBuilder.Create( _genomeIdSeq.Next(), _generationSeq.Peek, connGenes, parent.HiddenNodeIdArray)); }
/// <summary> /// Populates a matrix with random elements. /// </summary> /// <param name="matrix">The matrix to populate.</param> /// <param name="distribution">Continuous Random Distribution to generate elements from.</param> protected override void DoRandom(Matrix <Complex32> matrix, IContinuousDistribution distribution) { for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) { matrix.At(i, j, Convert.ToSingle(distribution.Sample())); } } }
/// <summary> /// Populates a matrix with random elements. /// </summary> /// <param name="matrix">The matrix to populate.</param> /// <param name="distribution">Continuous Random Distribution to generate elements from.</param> protected override void DoRandom(Matrix <double> matrix, IContinuousDistribution distribution) { for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) { matrix.At(i, j, distribution.Sample()); } } }
public void Invoke(double[] weightArr) { // Select a subset of connection genes to mutate. int[] selectedIdxArr = _selectionStrategy.SelectSubset(weightArr.Length); // Loop over the connection genes to be mutated, and mutate them. for (int i = 0; i < selectedIdxArr.Length; i++) { weightArr[selectedIdxArr[i]] += _dist.Sample(); } }
public static List<PatternClass> Create2dimSampleObject(IContinuousDistribution generator, IContinuousDistribution generator1, int count, int classNumber) { List<PatternClass> sampleObjects = new List<PatternClass>(); probabilityGenerator = new ContinuousUniform(0, 1); probabilityGenerator.RandomSource = new Random(DateTime.Now.Millisecond + 10); for (int i = 0; i < count; i++) { sampleObjects.Add(new PatternClass(new FeatureVector(generator.Sample(), generator1.Sample()), classNumber)); } return sampleObjects; }
/// <summary> /// Populates a matrix with random elements. /// </summary> /// <param name="matrix">The matrix to populate.</param> /// <param name="distribution">Continuous Random Distribution to generate elements from.</param> protected override void DoRandom(Matrix <Complex32> matrix, IContinuousDistribution distribution) { CommonParallel.For( 0, matrix.RowCount, i => { for (var j = 0; j < matrix.ColumnCount; j++) { matrix.At(i, j, Convert.ToSingle(distribution.Sample())); } }); }
/// <summary> /// Create a new child genome from a given parent genome. /// </summary> /// <param name="parent">The parent genome.</param> /// <returns>A new child genome.</returns> public NeatGenome <T> CreateChildGenome(NeatGenome <T> parent) { // Attempt to find a new connection that we can add to the genome. if (!TryGetConnection(parent, out DirectedConnection directedConn, out int insertIdx)) { // Failed to find a new connection. return(null); } // Determine the connection weight. // 50% of the time use weights very close to zero. // Note. this recreates the strategy used in SharpNEAT 2.x. // TODO: Reconsider the distribution of new weights and if there are better approaches (distributions) we could use. T weight = _rng.NextBool() ? _weightDistB.Sample() : _weightDistA.Sample(); // Create a new connection gene array that consists of the parent connection genes plus the new gene // inserted at the correct (sorted) position. var parentConnArr = parent.ConnectionGenes._connArr; var parentWeightArr = parent.ConnectionGenes._weightArr; int parentLen = parentConnArr.Length; // Create the child genome's ConnectionGenes object. int childLen = parentLen + 1; var connGenes = new ConnectionGenes <T>(childLen); var connArr = connGenes._connArr; var weightArr = connGenes._weightArr; // Copy genes up to insertIdx. Array.Copy(parentConnArr, connArr, insertIdx); Array.Copy(parentWeightArr, weightArr, insertIdx); // Copy the new genome into its insertion point. connArr[insertIdx] = new DirectedConnection( directedConn.SourceId, directedConn.TargetId); weightArr[insertIdx] = weight; // Copy remaining genes (if any). Array.Copy(parentConnArr, insertIdx, connArr, insertIdx + 1, parentLen - insertIdx); Array.Copy(parentWeightArr, insertIdx, weightArr, insertIdx + 1, parentLen - insertIdx); // Create and return a new genome. // Note. The set of hidden node IDs remains unchanged from the parent, therefore we are able to re-use // both parent.HiddenNodeIdArray and NodeIndexByIdMap. return(_genomeBuilder.Create( _genomeIdSeq.Next(), _generationSeq.Peek, connGenes, parent.HiddenNodeIdArray, parent.NodeIndexByIdMap)); }
/// <summary> /// Generates a vector with random elements /// </summary> /// <param name="length">Number of elements in the vector.</param> /// <param name="randomDistribution">Continuous Random Distribution or Source</param> /// <returns> /// A vector with n-random elements distributed according /// to the specified random distribution. /// </returns> /// <exception cref="ArgumentNullException">If the n vector is non positive<see langword="null" />.</exception> public override Vector <float> Random(int length, IContinuousDistribution randomDistribution) { if (length < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "length"); } var v = CreateVector(length); for (var index = 0; index < Count; index++) { v[index] = Convert.ToSingle(randomDistribution.Sample()); } return(v); }
/// <summary> /// Generates a vector with random elements /// </summary> /// <param name="length">Number of elements in the vector.</param> /// <param name="randomDistribution">Continuous Random Distribution or Source</param> /// <returns> /// A vector with n-random elements distributed according /// to the specified random distribution. /// </returns> /// <exception cref="ArgumentNullException">If the n vector is non positive<see langword="null" />.</exception> public override Vector <Complex32> Random(int length, IContinuousDistribution randomDistribution) { if (length < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "length"); } var v = (DenseVector)CreateVector(length); for (var index = 0; index < v.Data.Length; index++) { v.Data[index] = new Complex32((float)randomDistribution.Sample(), (float)randomDistribution.Sample()); } return(v); }
//static VectorBuilder<double> vBuilder; //public static Particle[] Generate2D(int numberOfParticles, IDistribution distributionx, IDistribution distributiony, IDistribution distributionv, IDistribution distributiono) //{ // return Enumerable.Range(0, numberOfParticles).Select(_ => // new Particle // ( // distributionx.Sample(), distributiony.Sample(), distributionv.Sample(), distributiono.Sample() % 2.0 * System.Math.PI, weight: 1d // ) // ).ToArray(); //} public static List <Particle> BuildSwarm(int numberOfParticles, IContinuousDistribution xdistribution, IContinuousDistribution ydistribution, IContinuousDistribution vdistribution = null, IContinuousDistribution odistribution = null) { return(Enumerable.Range(0, numberOfParticles).Select(_ => { var x = xdistribution.Sample(); var y = ydistribution.Sample(); var v = vdistribution?.Sample(); var o = odistribution?.Sample(); return new Particle(x, y, 1d / numberOfParticles) { Velocity = v ?? 0, Orientation = o ?? 0 }; }).ToList()); }
/// <summary> /// Create a new dense vector with values sampled from the provided random distribution. /// </summary> public static DenseVector CreateRandom(int length, IContinuousDistribution distribution) { return new DenseVector(DenseVectorStorage<double>.OfInit(length, i => distribution.Sample())); }
/// <summary> /// Create a new dense matrix with values sampled from the provided random distribution. /// </summary> public static DenseMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution) { return(new DenseMatrix(DenseColumnMajorMatrixStorage <Complex> .OfInit(rows, columns, (i, j) => new Complex(distribution.Sample(), distribution.Sample())))); }
/// <summary> /// Create a new dense vector with values sampled from the provided random distribution. /// </summary> public static DenseVector CreateRandom(int length, IContinuousDistribution distribution) { return new DenseVector(DenseVectorStorage<Complex32>.OfInit(length, i => new Complex32((float)distribution.Sample(), (float)distribution.Sample()))); }
/// <summary> /// Generates a vector with random elements /// </summary> /// <param name="length">Number of elements in the vector.</param> /// <param name="randomDistribution">Continuous Random Distribution or Source</param> /// <returns> /// A vector with n-random elements distributed according /// to the specified random distribution. /// </returns> /// <exception cref="ArgumentNullException">If the length vector is non poisitive<see langword="null" />.</exception> public override Vector Random(int length, IContinuousDistribution randomDistribution) { if (length < 0) { throw new ArgumentException(Resources.ArgumentMustBePositive, "length"); } var v = (SparseVector)this.CreateVector(length); for (var index = 0; index < v.Count; index++) { v[index] = randomDistribution.Sample(); } return v; }
/// <summary> /// Create a new dense vector with values sampled from the provided random distribution. /// </summary> public static DenseVector CreateRandom(int size, IContinuousDistribution distribution) { var storage = new DenseVectorStorage<Complex>(size); for (var i = 0; i < storage.Data.Length; i++) { storage.Data[i] = new Complex(distribution.Sample(), distribution.Sample()); } return new DenseVector(storage); }
/// <summary> /// Create a new dense matrix with values sampled from the provided random distribution. /// </summary> public static DenseMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution) { return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfInit(rows, columns, (i, j) => (float) distribution.Sample())); }
/// <summary> /// Computes and returns the next sample. /// </summary> public double ReadNextSample() { return(_distribution.Sample()); }
/// <summary> /// Create a new dense matrix with values sampled from the provided random distribution. /// </summary> public static DenseMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution) { var storage = new DenseColumnMajorMatrixStorage<Complex>(rows, columns); for (var i = 0; i < storage.Data.Length; i++) { storage.Data[i] = new Complex(distribution.Sample(), distribution.Sample()); } return new DenseMatrix(storage); }
float _GetBias() { return(_zeroBias ? 0f : Convert.ToSingle(_distribution.Sample())); }
/// <summary> /// Generates a vector with random elements /// </summary> /// <param name="length">Number of elements in the vector.</param> /// <param name="randomDistribution">Continuous Random Distribution or Source</param> /// <returns> /// A vector with n-random elements distributed according /// to the specified random distribution. /// </returns> /// <exception cref="ArgumentNullException">If the n vector is non positive<see langword="null" />.</exception> public override Vector<Complex32> Random(int length, IContinuousDistribution randomDistribution) { if (length < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "length"); } var v = (DenseVector)CreateVector(length); for (var index = 0; index < v.Data.Length; index++) { v.Data[index] = new Complex32((float)randomDistribution.Sample(), (float)randomDistribution.Sample()); } return v; }
/// <summary> /// Generates matrix with random elements. /// </summary> /// <param name="numberOfRows">Number of rows.</param> /// <param name="numberOfColumns">Number of columns.</param> /// <param name="distribution">Continuous Random Distribution or Source</param> /// <returns> /// An <c>numberOfRows</c>-by-<c>numberOfColumns</c> matrix with elements distributed according to the provided distribution. /// </returns> /// <exception cref="ArgumentException">If the parameter <paramref name="numberOfRows"/> is not positive.</exception> /// <exception cref="ArgumentException">If the parameter <paramref name="numberOfColumns"/> is not positive.</exception> public override Matrix Random(int numberOfRows, int numberOfColumns, IContinuousDistribution distribution) { if (numberOfRows < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "numberOfRows"); } if (numberOfColumns < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "numberOfColumns"); } var matrix = (SparseMatrix)CreateMatrix(numberOfRows, numberOfColumns); for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) { var value = distribution.Sample(); if (value != 0.0) { matrix.SetValueAt(i, j, value); } } } return matrix; }
/// <summary> /// Create a new dense vector with values sampled from the provided random distribution. /// </summary> public static DenseVector CreateRandom(int length, IContinuousDistribution distribution) { return(new DenseVector(DenseVectorStorage <double> .OfInit(length, i => distribution.Sample()))); }
/// <summary> /// Create a new diagonal matrix with diagonal values sampled from the provided random distribution. /// </summary> public static DiagonalMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution) { return(new DiagonalMatrix(DiagonalMatrixStorage <Complex32> .OfInit(rows, columns, i => new Complex32((float)distribution.Sample(), (float)distribution.Sample())))); }
private bool ShouldMutate() { return(_mutationRateDistribution.Sample() <= _parameters.MutationRate); }
public double Sample() { return(originalDistribution.Sample()); }
public float GetBias() { return(Convert.ToSingle(_distribution.Sample())); }
public double Sample() { return(estimate - originalDistribution.Sample()); }
/// <summary> /// Create a new dense vector with values sampled from the provided random distribution. /// </summary> public static DenseVector CreateRandom(int length, IContinuousDistribution distribution) { return(new DenseVector(DenseVectorStorage <Complex32> .OfInit(length, i => new Complex32((float)distribution.Sample(), (float)distribution.Sample())))); }
/// <summary> /// Create a new diagonal matrix with diagonal values sampled from the provided random distribution. /// </summary> public static DiagonalMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution) { return new DiagonalMatrix(DiagonalMatrixStorage<Complex>.OfInit(rows, columns, i => new Complex(distribution.Sample(), distribution.Sample()))); }
/// <summary> /// Create a new diagonal matrix with diagonal values sampled from the provided random distribution. /// </summary> public static DiagonalMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution) { return(new DiagonalMatrix(DiagonalMatrixStorage <double> .OfInit(rows, columns, i => distribution.Sample()))); }
private bool ShouldCrossover() { return(_crossoverRateDistribution.Sample() < _crossoverRate); }
/// <summary> /// Generates matrix with random elements. /// </summary> /// <param name="numberOfRows">Number of rows.</param> /// <param name="numberOfColumns">Number of columns.</param> /// <param name="distribution">Continuous Random Distribution or Source</param> /// <returns> /// An <c>numberOfRows</c>-by-<c>numberOfColumns</c> matrix with elements distributed according to the provided distribution. /// </returns> /// <exception cref="ArgumentException">If the parameter <paramref name="numberOfRows"/> is not positive.</exception> /// <exception cref="ArgumentException">If the parameter <paramref name="numberOfColumns"/> is not positive.</exception> public virtual Matrix Random(int numberOfRows, int numberOfColumns, IContinuousDistribution distribution) { if (numberOfRows < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "numberOfRows"); } if (numberOfColumns < 1) { throw new ArgumentException(Resources.ArgumentMustBePositive, "numberOfColumns"); } var matrix = CreateMatrix(numberOfRows, numberOfColumns); CommonParallel.For( 0, ColumnCount, j => { for (var i = 0; i < matrix.RowCount; i++) { matrix[i, j] = distribution.Sample(); } }); return matrix; }