NextDouble() { double xi, eta; do { double gen1 = 1.0 - RandomSource.NextDouble(); double gen2 = 1.0 - RandomSource.NextDouble(); if (gen1 <= _helper2) { xi = Math.Pow(gen1 / _helper2, 1.0 / _helper1); eta = gen2 * Math.Pow(xi, _helper1 - 1.0); } else { xi = 1.0 - Math.Log((gen1 - _helper2) / (1.0 - _helper2)); eta = gen2 * Math.Pow(Math.E, -xi); } }while(eta > Math.Pow(xi, _helper1 - 1.0) * Math.Pow(Math.E, -xi)); for (int i = 1; i <= _alpha; i++) { xi -= Math.Log(RandomSource.NextDouble()); } return(xi * _theta); }
public void Samples(double[] values) { for (int i = 0; i < values.Length; i++) { values[i] = InverseCumulativeDistribution(RandomSource.NextDouble()); } }
NextDouble() { // Note that this method generate two gaussian deviates // at once. The additional deviate is recorded in // <c>extraNormal</c>. // Using the extra gaussian deviate if available if (_extraNormal.HasValue) { double extraNormalCpy = _extraNormal.Value; _extraNormal = null; return(extraNormalCpy); } // Generating two new gaussian deviates double rsq, v1, v2; // We need a non-zero random point inside the unit circle. do { v1 = (2.0 * RandomSource.NextDouble()) - 1.0; v2 = (2.0 * RandomSource.NextDouble()) - 1.0; rsq = (v1 * v1) + (v2 * v2); }while(rsq > 1.0 || rsq == 0); // Make the Box-Muller transformation double fac = Math.Sqrt(-2.0 * Math.Log(rsq) / rsq); _extraNormal = v1 * fac; return(v2 * fac); }
/// <summary> /// Returns a sample from the distribution P. /// </summary> /// <exception cref="ArgumentOutOfRangeException">When the algorithms detects that the proposal /// distribution doesn't upper bound the target distribution.</exception> public override T Sample() { while (true) { // Get a sample from the proposal. T x = _proposal(); // Evaluate the density for proposal. double q = _pdfQ(x); // Evaluate the density for the target density. double p = _pdfP(x); // Sample a variable between 0.0 and proposal density. double u = RandomSource.NextDouble() * q; Samples++; if (q < p) { throw new ArgumentException("The sampler\'s proposal distribution is not upper bounding the target density."); } if (u < p) { Accepts++; return(x); } } }
RandomPermutation( int n ) { if (n < 0) { throw new ArgumentOutOfRangeException("size", n, Resources.ArgumentNotNegative); } IndexedValue[] indexedValues = new IndexedValue[n]; for (int i = 0; i < indexedValues.Length; i++) { indexedValues[i] = new IndexedValue(i, _random.NextDouble()); } // sorting the array (act as a random permutation) Array.Sort(indexedValues); // creating and returning the permutation int[] permutation = new int[n]; for (int i = 0; i < n; i++) { permutation[i] = indexedValues[i].Index; } return(permutation); }
/// <summary> /// Returns a sample from the distribution P. /// </summary> /// <exception cref="ArgumentOutOfRangeException">When the algorithms detects that the proposal /// distribution doesn't upper bound the target distribution.</exception> public override T Sample() { while (true) { // Get a sample from the proposal. T x = _proposal(); // Evaluate the density for proposal. double q = _pdfQ(x); // Evaluate the density for the target density. double p = _pdfP(x); // Sample a variable between 0.0 and proposal density. double u = RandomSource.NextDouble() * q; Samples++; if (q < p) { throw new ArgumentOutOfRangeException(Resources.ProposalDistributionNoUpperBound); } if (u < p) { Accepts++; return(x); } } }
/// <summary> /// Returns the next zipfian deviate. /// </summary> public double Next() { /* A transformation method (similar to the exponential * generator) is used here to generate a zipfian deviate. */ double p = _random.NextDouble(); return(Math.Pow(1d - p, 1d / (1d - _skew))); }
NextInt32() { if (RandomSource.NextDouble() < _p) { return(1); } return(0); }
NextInt32() { int count = 0; for (double product = RandomSource.NextDouble(); product >= _helper1; product *= RandomSource.NextDouble()) { count++; } return(count); }
NextDouble() { double genNum = RandomSource.NextDouble(); if (genNum <= _lowerPart / _diff) { return(_a + (Math.Sqrt(genNum) * _helper3)); } return(_b - (Math.Sqrt((genNum * _diff) - _lowerPart) * _helper4)); }
NextInt32() { // TODO: Implement direct transformation instead of simulation int samples; for (samples = 1; RandomSource.NextDouble() >= _p; samples++) { } return(samples); }
NextDouble() { double product = 1.0; for (int i = 0; i < _shape; i++) { // Subtract random number from 1.0 to avoid Math.Log(0.0) product *= (1.0 - RandomSource.NextDouble()); } return(_helper1 * Math.Log(product)); }
/// <summary> /// This method runs the sampler for a number of iterations without returning a sample /// </summary> private void Burn(int n) { for (int i = 0; i < n; i++) { double x_l = mCurrent; double x_r = mCurrent; double xnew = mCurrent; // The logarithm of the slice height. double lu = System.Math.Log(RandomSource.NextDouble()) + mCurrentDensityLn; // Create a horizontal interval (x_l, x_r) enclosing x. double r = RandomSource.NextDouble(); x_l = mCurrent - r * Scale; x_r = mCurrent + (1.0 - r) * Scale; // Stepping out procedure. while (mPdfLnP(x_l) > lu) { x_l -= Scale; } while (mPdfLnP(x_r) > lu) { x_r += Scale; } // Shrinking: propose new x and shrink interval until good one found. while (true) { xnew = RandomSource.NextDouble() * (x_r - x_l) + x_l; mCurrentDensityLn = mPdfLnP(xnew); if (mCurrentDensityLn > lu) { mCurrent = xnew; mAccepts++; mSamples++; break; } if (xnew > mCurrent) { x_r = xnew; } else { x_l = xnew; } } } }
/// <summary> /// This method runs the sampler for a number of iterations without returning a sample /// </summary> private void Burn(int n) { for (int i = 0; i < n; i++) { // The logarithm of the slice height. double lu = Math.Log(RandomSource.NextDouble()) + _currentDensityLn; // Create a horizontal interval (x_l, x_r) enclosing x. double r = RandomSource.NextDouble(); double xL = _current - r * Scale; double xR = _current + (1.0 - r) * Scale; // Stepping out procedure. while (_pdfLnP(xL) > lu) { xL -= Scale; } while (_pdfLnP(xR) > lu) { xR += Scale; } // Shrinking: propose new x and shrink interval until good one found. while (true) { double xnew = RandomSource.NextDouble() * (xR - xL) + xL; _currentDensityLn = _pdfLnP(xnew); if (_currentDensityLn > lu) { _current = xnew; Accepts++; Samples++; break; } if (xnew > _current) { xR = xnew; } else { xL = xnew; } } } }
NextInt32() { double rnd = RandomSource.NextDouble(); if (rnd >= _cdf[_n - 1]) { return(_last); } // TODO: consider using binary search instead int index = 0; while (_cdf[index] < rnd) { index++; } return(index + _first); }
public double Sample() { return(InverseCumulativeDistribution(RandomSource.NextDouble())); }
NextDouble() { // Subtract random number from 1.0 to avoid Math.Log(0.0) return(_helper1 * Math.Log(1.0 - RandomSource.NextDouble())); }
NextDouble() { return(_sigma * Math.Sqrt(-2 * Math.Log(1 - RandomSource.NextDouble()))); }
NextInt32() { // TODO: Implement direct transformation instead of simulation int successes = 0; for (int i = 0; i < _n; i++) { if (RandomSource.NextDouble() < _p) { successes++; } } return(successes); // ALTERNATIVE IMPLEMENTATION (by Thaddaeus Parker/NR), CONSIDER USE THIS INSTEAD: /* * * * /// <summary> * /// Returns a number from an integer value that is a random deviate drawn from a binomial distribution of * /// numTrials each of probability "probability", using the System.Random as a source of uniform random deviates. * /// </summary> * /// <param name="probability">The probability of each trial</param> * /// <param name="numberTrials">The number of trials to perform</param> * /// <returns>A binomial deviated floating point number</returns> * public double Next(double probability, int numberTrials) * { * double inProbability; //used for the next function * * double amount, //the mean deviate to produce * em, * angle, //an angle that is temporarily calculated for each iteration * binomial; //the binomial return value * int count = 0; * double tmp; //used for gathering temporary deviations * double yangle; //used for finding tmp value * double root; //finds the root of amount of trials for the probability cause * //reset the probability and number of trials but keep the same seed. * _probability = (probability <= 0.5d) ? probability : 1.0 - probability; * amount = numberTrials * _probability; //mean deviate produced * _numberTrials = numberTrials; * inProbability = probability; * if(_numberTrials < 25) * { //use the direct method while numberTrials is not too large * binomial = 0.0; * for(count = 1; count <= _numberTrials; count++) * { * if(random.NextDouble() < _probability) ++binomial; * } * } * else if(amount < 1.0) * { //if fewer than one event is expected our of 25+ trials, then the distribution * //is quite accurately Poisson. Use the direct Poisson method * double g = System.Math.Exp(-amount); * double t = 1.0; * for(count = 0; count <= _numberTrials; count++) * { * t *= random.NextDouble(); * if(t < g) * break; * } * binomial = ((count <= _numberTrials) ? count : _numberTrials); * } * else * { * //use rejection method * if(_numberTrials != oldNumber) * { //if numberTrials has changed then compute useful quantities * en = numberTrials; * oldGamma = Fn.GammaLn(en + 1.0); * oldNumber = numberTrials; * } * if(_probability != oldProbability) * { //if _probability has changed, then compute useful quantities * pc = 1.0 - _probability; * probabilityLog = System.Math.Log(_probability); * pclog = System.Math.Log(pc); * oldProbability = _probability; * } * root = System.Math.Sqrt(2.0 * amount * pc); * do * { // The following code is rejection method with a lorentzian comparison function * do * { * angle = System.Math.PI * random.NextDouble(); * yangle = System.Math.Tan(angle); * em = root * yangle + amount; //trick for integer distribution * } while(em < 0.0 || em >= (en + 1.0)); //reject * em = System.Math.Floor(em); * tmp = 1.2 * root * (1.0 + yangle * yangle) * System.Math.Exp(oldGamma - Fn.GammaLn(em + 1.0) - Fn.GammaLn(en - em + 1.0) + em * probabilityLog + (en - em) * pclog); * } while(random.NextDouble() > tmp); //reject; this happens about 1.5 times per deviate, on avg * binomial = em; * } * if(_probability != probability) * binomial = numberTrials - binomial; // remember to undo the symmetry transformation * return binomial; * } * * * */ }
/// <summary> /// Gets a list of random indices into an array, depending on various settings. /// </summary> /// <param name="numberOfLocationsToChooseFrom">The array length, indexes to which will be returned.</param> /// <param name="maximumNumberOfLocations">The maximum number of locations to select.</param> /// <param name="selectionWithReplacement"><see langword="true"/> if the same location can be returned more than once.</param> /// <param name="lambda">The probability of choosing a location at all.</param> /// <returns>A list of locations in the original array.</returns> public int[] GetLocations( int numberOfLocationsToChooseFrom, int maximumNumberOfLocations = 1, bool selectionWithReplacement = false, double lambda = 0.1) { if (maximumNumberOfLocations <= 0) { throw new ArgumentOutOfRangeException(nameof(maximumNumberOfLocations), "Maximum number of locations must be greater than 0."); } if (!selectionWithReplacement && maximumNumberOfLocations > numberOfLocationsToChooseFrom) { throw new ArgumentOutOfRangeException(nameof(maximumNumberOfLocations), "If sampling without replacement, cannot ask for more locations than are available."); } if (lambda < 0 || lambda > 1) { throw new ArgumentOutOfRangeException(nameof(lambda), "The probability of selecting a location must be between 0 and 1."); } if (lambda == 0) { return(new int[0]); } if (lambda == 1 && !selectionWithReplacement) { // There's a fast function implemented for this... return(Enumerable.Range(0, numberOfLocationsToChooseFrom) .SelectCombination(maximumNumberOfLocations, Rng) .ToArray()); } var locations = new List <int>(); var i = 0; while (i < maximumNumberOfLocations) { // See if we will make a selection var mutate = Rng.NextDouble() < lambda; if (mutate) { // See if we need to reduce the randomisation space var offset = selectionWithReplacement ? 0 : locations.Count; // Generate a value var location = Rng.Next(0, numberOfLocationsToChooseFrom - offset); if (selectionWithReplacement) { // We are generating with replacement - just add to list. locations.Add(location); } else { // Find the true value which the truncated space refers to while (locations.Contains(location)) { location++; } // Add to list locations.Add(location); } } i++; } return(locations.ToArray()); }
NextDouble() { return(_location + (_scale * Trig.Tangent(Constants.Pi * (RandomSource.NextDouble() - 0.5)))); }
NextDouble() { return(_a + (RandomSource.NextDouble() * _diff)); }
NextDouble() { return(_location / Math.Pow(1.0 - RandomSource.NextDouble(), _helper1)); }
/// <summary> /// Implements random number generation for this variable /// </summary> /// <returns>A legal value (double).</returns> public object GetNextRandom(RandomSource rng) { return((rng.NextDouble() * (upperBoundForGeneration - lowerBoundForGeneration)) + lowerBoundForGeneration); }
public static double Get(this RangeDouble d, RandomSource rand) { return(rand.NextDouble(d.Max - d.Min) + d.Min); }
NextDouble() { double rand = 0.5 - RandomSource.NextDouble(); return(_location - (_scale * Math.Sign(rand) * Math.Log(2.0 * Math.Abs(rand)))); }