private static MapPixel[] MutateSequence(MapPixel[] mutationSequence, int mutationCount)
{
var indexesForChanging = new List <int>(mutationCount);
if (mutationCount >= mutationSequence.Length)
{
for (var index = 0; index < mutationSequence.Length; index++)
{
indexesForChanging.Add(index);
}
}
else
{
for (var mutation = 0; mutation < mutationCount; mutation++)
{
int randomIndex;
do
{
randomIndex = (int)RandomNumberSource.GetRandomNumber().Map(0, 1, 0, mutationSequence.Length);
} while (indexesForChanging.Contains(randomIndex));
indexesForChanging.Add(randomIndex);
}
}
foreach (var index in indexesForChanging)
{
mutationSequence[index] = PixelPicker.GetNewRandomPixel(mutationSequence[index]);
}
return(mutationSequence);
}
private bool DetermineWhetherMapShouldChange(double currentEnergy, double energyIfChanged)
{
var randomNumber = RandomNumberSource.GetRandomNumber();
var currentEnergyMapProbability = Math.Exp(_temperature * currentEnergy);
var changedEnergyMapProbability = Math.Exp(_temperature * energyIfChanged);
var ratioOfChangedAndCurrentProbabilities = changedEnergyMapProbability / currentEnergyMapProbability;
var mapModificationProbability = Math.Min(ratioOfChangedAndCurrentProbabilities, 1);
return(randomNumber < mapModificationProbability);
}
private static MapPixel GetNewRandomPixel(MapPixel currentPixel)
{
var mapPixelValues = ((MapPixel[])Enum.GetValues(typeof(MapPixel))).ToList();
int randomPixelIndex;
do
{
randomPixelIndex = (int)RandomNumberSource.GetRandomNumber().Map(0, 1, 0, mapPixelValues.Count);
} while (mapPixelValues[randomPixelIndex] == currentPixel);
return(mapPixelValues[randomPixelIndex]);
}
public void Play()
{
double chance = Math.Round(50.12345, 3);
int intChance = Convert.ToInt32(chance * 1000);
int value = RandomNumberSource.GetNext(100000);
if (value < intChance)
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
}
public MapPixel[] NextValue()
{
for (var i = 0; i < CurrentValue.Length; i++)
{
var randomNumber = RandomNumberSource.GetRandomNumber();
if (randomNumber >= Config.MutationChance)
{
continue;
}
ChangePixel(i);
}
return(CurrentValue);
}
public MarkovNode <TNodeType> GetNextNode()
{
double randomNumber = RandomNumberSource.GetRandomNumber();
double connectionSum = 0;
foreach (var connection in _connections)
{
connectionSum += connection.Weight;
if (connectionSum >= randomNumber)
{
return(connection.Target);
}
}
return(this);
}
private MapPixel[,] IsingIteration(MapPixel[,] map)
{
var x = (int)RandomNumberSource.GetRandomNumber().Map(0, 1, 0, map.GetLength(0));
var y = (int)RandomNumberSource.GetRandomNumber().Map(0, 1, 0, map.GetLength(1));
var valueIfPointIsChanged = PixelPicker.GetNewRandomPixel(map[x, y]);
var currentEnergyAtLocation = EnergyAtPoint(map, x, y);
var energyIfLocationIsChanged = EnergyAtPoint(map, x, y, valueIfPointIsChanged);
var mapShouldChange = DetermineWhetherMapShouldChange(currentEnergyAtLocation, energyIfLocationIsChanged);
if (mapShouldChange)
{
map[x, y] = valueIfPointIsChanged;
}
return(map);
}
private MarkovNode <TNodeType> PickRandomNode(List <MarkovNode <TNodeType> > possibleNodes)
{
double result = RandomNumberSource.GetRandomNumber();
double nodeValue = 1.0 / possibleNodes.Count;
double nodeValueTotal = 0;
foreach (var node in possibleNodes)
{
nodeValueTotal += nodeValue;
if (nodeValueTotal >= result)
{
return(node);
}
}
return(possibleNodes[0]);
}
public MapPixel[,] GenerateMap(int mapWidth, int mapHeight)
{
var markovChain = GetMarkovChain();
var map = new MapPixel[mapWidth, mapHeight];
var mutationSequence = GetRandomSequence(mapWidth, markovChain);
for (var y = 0; y < mapHeight; y++)
{
for (var x = 0; x < mapWidth; x++)
{
map[x, y] = mutationSequence[x];
}
var mutationCount = (int)Math.Round(RandomNumberSource.GetRandomNumber().Map(0, 1, _minimumMutations, _maximumMutations));
mutationSequence = MutateSequence(mutationSequence, mutationCount);
}
return(map);
}
public MapPixel NextValue()
{
var randomNumber = RandomNumberSource.GetRandomNumber();
if (_currentValue == MapPixel.Land)
{
if (randomNumber >= Config.LandToLandWeight)
{
_currentValue = MapPixel.Water;
}
}
else
{
if (randomNumber >= Config.WaterToWaterWeight)
{
_currentValue = MapPixel.Land;
}
}
return(_currentValue);
}
private MapPixel GetRandomPixel()
{
var randomValue = RandomNumberSource.GetRandomNumber();
return(randomValue < 0.5 ? MapPixel.Land : MapPixel.Water);
}
/// <summary>
/// Gets a random gene.
/// </summary>
/// <example>
/// genotype.Add(Gene.GetRandomGene());
/// </example>
/// <returns>
/// A random gene <see cref="Gene"/>.
/// </returns>
public static Gene GetRandomGene()
{
return(RandomNumberSource.GetNext(1) == 1 ? new Gene(true) : new Gene(false));
}
private MapPixel GetRandomPixel()
{
var randomNumber = RandomNumberSource.GetRandomNumber();
return randomNumber < 0.5 ? MapPixel.Land : MapPixel.Water;
}
