public int Next()
{
var realNext = _next == _min ? _min : _base.Next(_min, _next);
_next = _base.Next(_min, _max);
return(realNext);
}
RandomCombination(
int n,
int k
)
{
bool[] selection = new bool[n];
if (k * 3 < n)
{
// just pick and try
int selectionCount = 0;
while (selectionCount < k)
{
int index = _random.Next(n);
if (!selection[index])
{
selection[index] = true;
selectionCount++;
}
}
return(selection);
}
else
{
// based on permutation
int[] permutation = RandomPermutation(n);
for (int i = 0; i < k; i++)
{
selection[permutation[i]] = true;
}
return(selection);
}
}
public DoubleRundom(RandomSource @base, int min, int max)
{
_base = @base;
_min = min;
_max = max;
_next = @base.Next(min, max);
}
/// <inheritdoc/>
protected override int GetNextRandom(int sides)
{
if (sides < 2)
{
throw new ArgumentOutOfRangeException(nameof(sides));
}
return(randomSource.Next(0, sides) + 1);
}
public static int Get(this RangeInt32 range, RandomSource rand)
{
if (range.Min == range.Max)
{
return(range.Min);
}
else
{
return(rand.Next(range.Min, range.Max + 1));
}
}
private static void Shuffle <T>(this IList <T> list)
{
int n = list.Count;
while (n > 1)
{
n--;
int k = RandomSource.Next(n + 1);
T value = list[k];
list[k] = list[n];
list[n] = value;
}
}
private ParetoFrontPoint MakeTournamentSelection(IReadOnlyList <ParetoFrontPoint> paretoFrontItems)
{
var best = paretoFrontItems[RandomSource.Next(paretoFrontItems.Count)];
for (var i = 2; i <= _populationParameters.TournamentSize; i++)
{
var next = paretoFrontItems[RandomSource.Next(paretoFrontItems.Count)];
if (next.IsBetterThan(best))
{
best = next;
}
}
return(best);
}
private Genome Reproduce(IReadOnlyList <ParetoFrontPoint> paretoFrontPoints)
{
var p1 = MakeTournamentSelection(paretoFrontPoints);
if (RandomSource.Next() < 0.8f)
{
return(_neatPopulation.Replicator.Reproduce(p1.Genome));
}
var p2 = MakeTournamentSelection(paretoFrontPoints);
return(p1.Fitness > p2.Fitness
? _neatPopulation.Replicator.Reproduce(p1.Genome, p2.Genome)
: _neatPopulation.Replicator.Reproduce(p2.Genome, p1.Genome));
}
public void NextTest(int min, int max)
{
var uut = new RandomSource();
var random = uut.Next(min, max);
if (max > min)
{
Assert.True(random >= min);
Assert.True(random <= max);
}
else
{
Assert.True(random >= max);
Assert.True(random <= min);
}
}
/// <returns>
/// The simulated time.
/// TimeSpan.Zero if no time progress was achieved due to delta events.
/// TimeSpan.MinValue if no events were available.
/// </returns>
private TimeSpan RunSignalAssignmentPhase(bool progressTime)
{
_phase = SchedulerPhase.SignalAssignment;
TimeSpan simulatedTime = TimeSpan.Zero;
while (progressTime && _deltaEvents.Count == 0)
{
TimeSpan timespan;
if (_timeline.TryNextEventTime(out timespan))
{
_schedule.ProgressTime(timespan, this);
OnSimulationTimeProgress(timespan);
simulatedTime += timespan;
}
else
{
_phase = SchedulerPhase.Idle;
return(TimeSpan.MinValue);
// TODO: check, why MinValue?
}
}
if (_deltaEvents.Count > 0)
{
int index = _random.Next(_deltaEvents.Count);
SchedulerEventItem item = _deltaEvents[index];
_deltaEvents.RemoveAt(index);
ISchedulable subject = item.Subject;
if (subject.CurrentValue == null || !subject.CurrentValue.Equals(item.Value))
{
item.Subject.CurrentValue = item.Value;
_schedulablesWithEvent.Add(item.Subject);
}
}
_phase = SchedulerPhase.Idle;
return(simulatedTime);
}
public Int32 RollDie(int sides)
{
return(_source.Next(0, sides) + 1);
}
public IFieldsGraph Build()
{
var blackCount = Math.Floor(blackProbability * _rowCount * _columnCount);
_rowCount = _rowCount + 4;
_columnCount = _columnCount + 2;
var input = new FieldType[_rowCount][];
for (int row = 0; row < _rowCount; ++row)
{
input[row] = new FieldType[_columnCount];
for (int column = 0; column < _columnCount; ++column)
{
input[row][column] = FieldType.Empty;
// if (row < 2 || column < 1 || row >= _rowCount - 2 || column >= _columnCount - 1)
// {
// continue;
// }
// var placeBlack = _random.NextDouble() < blackProbability;
// if (placeBlack)
// {
// input[row][column] = FieldType.Black;
// }
}
}
while (blackCount > 0)
{
var rowIndex = RandomSource.Next(2, _rowCount - 2);
var colIndex = RandomSource.Next(1, _columnCount - 1);
if (input[rowIndex][colIndex] == FieldType.Empty)
{
input[rowIndex][colIndex] = FieldType.Black;
blackCount--;
}
}
bool whiteWasPlaced = false;
for (int row = _rowCount / 2, row2 = _rowCount / 2 + 1;
row >= 2 && row2 < _rowCount - 2 && !whiteWasPlaced;
--row, ++row2)
{
for (int col = (_columnCount) / 2, col2 = (_columnCount / 2) + 1;
col >= 1 && col2 <= _columnCount - 1;
++col2,
--col)
{
if (input[row][col] == FieldType.Empty)
{
input[row][col] = FieldType.White;
whiteWasPlaced = true;
break;
}
if (input[row2][col] == FieldType.Empty)
{
input[row2][col] = FieldType.White;
whiteWasPlaced = true;
break;
}
if (input[row][col2] == FieldType.Empty)
{
input[row][col2] = FieldType.White;
whiteWasPlaced = true;
break;
}
if (input[row2][col2] == FieldType.Empty)
{
input[row2][col2] = FieldType.White;
whiteWasPlaced = true;
break;
}
}
}
if (whiteWasPlaced == false)
{
throw new InvalidOperationException();
}
return(new TestFieldsGraph(input).Build());
}
/// <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());
}
NextInt32()
{
return(RandomSource.Next(_a, _b + 1));
}
/// <summary>
/// Implements random number generation for this variable.
/// </summary>
/// <returns>A legal object (int).</returns>
public object GetNextRandom(RandomSource rng)
{
return(rng.Next(lowerBoundForGeneration, upperBoundForGeneration));
}
public static IEnumerable <T> Randomize <T>(this IEnumerable <T> e, RandomSource rand)
{
return(e.OrderBy <T, int>((item) => rand.Next()));
}
