/// <summary>Accepts an event attendee with specified properties.</summary> /// <param name="age">The attendee age.</param> /// <param name="gender">The attendee gender.</param> /// <param name="education">The attendee education.</param> /// <param name="wealth">The attendee wealth.</param> /// <param name="wellbeing">The attendee wellbeing.</param> /// <param name="happiness">The attendee happiness.</param> /// <param name="randomizer">A reference to the game's randomizer.</param> /// <returns> /// <c>true</c> if the event attendee with specified properties is accepted and can attend this city event; /// otherwise, <c>false</c>. /// </returns> public override bool TryAcceptAttendee( Citizen.AgeGroup age, Citizen.Gender gender, Citizen.Education education, Citizen.Wealth wealth, Citizen.Wellbeing wellbeing, Citizen.Happiness happiness, IRandomizer randomizer) { if (attendeesCount > eventTemplate.Capacity) { return(false); } if (eventTemplate.Costs != null && eventTemplate.Costs.Entry > GetCitizenBudgetForEvent(wealth, randomizer)) { return(false); } CityEventAttendees attendees = eventTemplate.Attendees; float randomPercentage = randomizer.GetRandomValue(100u); if (!CheckAge(age, attendees, randomPercentage)) { return(false); } randomPercentage = randomizer.GetRandomValue(100u); if (!CheckGender(gender, attendees, randomPercentage)) { return(false); } randomPercentage = randomizer.GetRandomValue(100u); if (!CheckEducation(education, attendees, randomPercentage)) { return(false); } randomPercentage = randomizer.GetRandomValue(100u); if (!CheckWealth(wealth, attendees, randomPercentage)) { return(false); } randomPercentage = randomizer.GetRandomValue(100u); if (!CheckWellbeing(wellbeing, attendees, randomPercentage)) { return(false); } randomPercentage = randomizer.GetRandomValue(100u); if (!CheckHappiness(happiness, attendees, randomPercentage)) { return(false); } attendeesCount++; return(true); }
/// <summary> /// Construct a neural genetic algorithm. /// </summary> /// /// <param name="network">The network to base this on.</param> /// <param name="randomizer">The randomizer used to create this initial population.</param> /// <param name="calculateScore">The score calculation object.</param> /// <param name="populationSize">The population size.</param> /// <param name="mutationPercent">The percent of offspring to mutate.</param> /// <param name="percentToMate">The percent of the population allowed to mate.</param> public NeuralGeneticAlgorithm(BasicNetwork network, IRandomizer randomizer, ICalculateScore calculateScore, int populationSize, double mutationPercent, double percentToMate) : base(TrainingImplementationType.Iterative) { Genetic = new NeuralGeneticAlgorithmHelper { CalculateScore = new GeneticScoreAdapter(calculateScore) }; IPopulation population = new BasicPopulation(populationSize); Genetic.MutationPercent = mutationPercent; Genetic.MatingPopulation = percentToMate*2; Genetic.PercentToMate = percentToMate; Genetic.Crossover = new Splice(network.Structure.CalculateSize()/3); Genetic.Mutate = new MutatePerturb(4.0d); Genetic.Population = population; for (int i = 0; i < population.PopulationSize; i++) { var chromosomeNetwork = (BasicNetwork) (network .Clone()); randomizer.Randomize(chromosomeNetwork); var genome = new NeuralGenome(chromosomeNetwork) {GA = Genetic}; Genetic.PerformCalculateScore(genome); Genetic.Population.Add(genome); } population.Sort(); }
public double[] LikelihoodWeighting(string X, Dictionary <string, bool?> evidence, int numberOfSamples, IRandomizer r) { var retval = new double[2]; for (int i = 0; i < numberOfSamples; i++) { var x = new Dictionary <string, bool?>(); var w = 1.0; var bayesNetNodes = this.GetVariableNodes(); foreach (BayesNetNode node in bayesNetNodes) { if (evidence[node.Variable] != null) { w *= node.ProbabilityOf(x); x[node.Variable] = evidence[node.Variable]; } else { x[node.Variable] = node.IsTrueFor(r.NextDouble(), x); } } bool?queryValue = (x[X]); if (queryValue == true) { retval[0] += w; } else { retval[1] += w; } } return(Util.Util.Normalize(retval)); }
/// <summary> /// Shuffle the input string using the given type /// </summary> /// <param name="input"> Input string</param> /// <param name="randomizer"> Randomizer to use </param> /// <returns>Shuffled string</returns> private string Shuffle(string input, IRandomizer randomizer) { // If the input is empty or of length 1 then just return the input string if (string.IsNullOrEmpty(input) || input.Length < 2) { return(input); } // We will just randomize string characters based on the input string's length // We could have chosen a random number but input length will add some more randomness int length = input.Length - 1; // Since strings are immutables, we will convert the input string to char array for easy swapping char[] charArray = input.ToArray <char>(); // Just loop the length of the string and swap random characters for (int index = 0; index < length; index++) { int rngIdx = randomizer.GetRandomInt(0, length); // Get a random index from the range char temp = charArray[index]; charArray[index] = charArray[rngIdx]; charArray[rngIdx] = temp; } return(new string(charArray)); }
public LayoutGenerator( LayoutConfiguration layoutConfiguration, IRandomizer rand, SettingConfiguration baseConfiguration, ControlConfiguration controlConfiguration, Action <string> logAction = null) { _logAction = logAction; String errorMessage = ""; if (!layoutConfiguration.isValid(out errorMessage)) { throw new ArgumentException("LayoutConfiguration is not valid. " + errorMessage); } baseConfiguration.InventoryConfiguration.autogenerate(); if (!baseConfiguration.InventoryConfiguration.isValid(layoutConfiguration.PodCapacity, out errorMessage)) { throw new ArgumentException("InventoryConfiguration is not valid. " + errorMessage); } if (!controlConfiguration.IsValid(out errorMessage)) { throw new ArgumentException("ControlConfiguration is not valid. " + errorMessage); } this.rand = rand; this.baseConfiguration = baseConfiguration; elevatorPositions = new Dictionary <Tuple <double, double>, Elevator>(); elevatorWaypoints = new Dictionary <Elevator, List <Waypoint> >(); elevatorSemaphores = new Dictionary <Waypoint, QueueSemaphore>(); instance = Instance.CreateInstance(this.baseConfiguration, controlConfiguration); instance.Name = layoutConfiguration.NameLayout; this.lc = layoutConfiguration; }
public ParticleManager(IEventAggregator eventAggregator, IDrawer drawer, IRandomizer randomizer) { _eventAggregator = eventAggregator; _drawer = drawer; _randomizer = randomizer; _particles = new List <Particle>(); }
public CharacterBuilder(RaceRepository raceRepository, ClassRepository classRepository, IStatsComputer statsComputer, IRandomizer randomizer) { RaceRepository = raceRepository; ClassRepository = classRepository; StatsComputer = statsComputer; Randomizer = randomizer; }
public StoryboardParserTests() { blockFactory = new FakeBlockFactory(); dismissNodes = new(); parsingContext = A.Fake<IParsingContext>(i => i.Strict()); A.CallTo(() => parsingContext.RegisterDismissNode(A<INode>.Ignored)) .Invokes(i => dismissNodes.Add(i.Arguments.Get<INode>(0))); A.CallTo(() => parsingContext.BlockFactory).Returns(blockFactory); rootBlockParser = A.Fake<IRootBlockParser>(i => i.Strict()); sceneNavigator = A.Fake<ISceneNavigator>(i => i.Strict()); eventManager = A.Fake<IEventManager>(i => i.Strict()); randomizer = A.Fake<IRandomizer>(i => i.Strict()); navigationState = A.Fake<INavigationState>(i => i.Strict()); variableDictionary = A.Fake<IVariableDictionary>(i => i.Strict()); blockState = A.Fake<IBlockState>(i => i.Strict()); var serviceProvider = A.Fake<IServiceProvider>(i => i.Strict()); A.CallTo(() => serviceProvider.GetService(typeof(IParsingContext))).Returns(parsingContext); A.CallTo(() => serviceProvider.GetService(typeof(IRootBlockParser))).Returns(rootBlockParser); A.CallTo(() => serviceProvider.GetService(typeof(ISceneNavigator))).Returns(sceneNavigator); A.CallTo(() => serviceProvider.GetService(typeof(IEventManager))).Returns(eventManager); A.CallTo(() => serviceProvider.GetService(typeof(IRandomizer))).Returns(randomizer); A.CallTo(() => serviceProvider.GetService(typeof(INavigationState))).Returns(navigationState); A.CallTo(() => serviceProvider.GetService(typeof(IVariableDictionary))).Returns(variableDictionary); A.CallTo(() => serviceProvider.GetService(typeof(IBlockState))).Returns(blockState); sut = new StoryboardParser(serviceProvider); }
public void Setup() { _fieldFactory = new FakeFieldFactory(); _randomizer = Substitute.For <IRandomizer>(); _randomizer.GetNext().Returns((uint)2); _uut = new Roulette(_fieldFactory, _randomizer); }
public EvaluationContext( string name, ISpiceNetlistCaseSensitivitySettings caseSettings, IRandomizer randomizer, IExpressionParserFactory expressionParserFactory, IExpressionFeaturesReader expressionFeaturesReader, IExpressionValueProvider expressionValueProvider, INameGenerator nameGenerator, IResultService resultService) { _caseSettings = caseSettings; ExpressionParserFactory = expressionParserFactory; ExpressionFeaturesReader = expressionFeaturesReader; ExpressionValueProvider = expressionValueProvider; NameGenerator = nameGenerator; ResultService = resultService; Name = name; Parameters = new Dictionary <string, Expression>(StringComparerProvider.Get(caseSettings.IsParameterNameCaseSensitive)); Arguments = new Dictionary <string, Expression>(StringComparerProvider.Get(caseSettings.IsParameterNameCaseSensitive)); Functions = new Dictionary <string, List <IFunction> >(StringComparerProvider.Get(caseSettings.IsFunctionNameCaseSensitive)); Children = new List <EvaluationContext>(); ExpressionRegistry = new ExpressionRegistry(caseSettings.IsParameterNameCaseSensitive, caseSettings.IsExpressionNameCaseSensitive); FunctionsBody = new Dictionary <string, string>(); FunctionArguments = new Dictionary <string, List <string> >(); Randomizer = randomizer; }
public Roulette(IFieldGenerator fieldGenerator, IRandomizer randomizer) { _fieldGenerator = fieldGenerator; _randomizer = randomizer; _fields = _fieldGenerator.CreateFields(); _result = _fields[0]; }
public void ProcessMap(Map <T> map, DungeonConfiguration configuration, IRandomizer randomizer) { var deadends = map.AllCells.Where(cell => cell.Sides.Values.Count(type => type) == 1).ToList(); foreach (var cell in deadends) { if (randomizer.GetRandomDouble() > configuration.ChanceToRemoveDeadends) { continue; } var currentCell = cell; var previousCell = map.GetAdjacentCell(cell, cell.Sides.First(pair => pair.Value).Key); var connected = false; while (!connected) { var direction = GetRandomValidDirection(map, currentCell, previousCell, randomizer); if (!direction.HasValue) { break; } var adjacentCell = map.GetAdjacentCell(currentCell, direction.Value); connected = adjacentCell.IsOpen; adjacentCell.IsOpen = true; currentCell.Sides[direction.Value] = adjacentCell.Sides[direction.Value.Opposite()] = true; previousCell = currentCell; currentCell = adjacentCell; } } }
public static IZooDatabase FromFile(IRandomizer randomizer, IAnimalNamesDatabase animalNamesDatabase, string filename, bool createIfNotExist = true) { var database = new ZooDatabase(randomizer, animalNamesDatabase, filename); if (createIfNotExist && !File.Exists(filename)) { database.Save(); // force generate an empty database file return(database); } var doc = new XmlDocument(); doc.Load(filename); foreach (XmlNode node in doc.SelectNodes("Zoo/Animals/Animal")) { // attempt to find the animal type by full name var type = Assembly.GetExecutingAssembly().GetType(node.Attributes["Type"].InnerText); if (type != null) { var id = Guid.Parse(node.Attributes["Id"].InnerText); var name = node.Attributes["Name"].InnerText; var age = new TimeSpan(long.Parse(node.Attributes["Age"].InnerText)); // construct an instance of the animal var animal = ConstructAnimal(type, id, name, age); // add animal to database (not saved yet) database._animals.Add(animal.Id, animal); } } return(database); }
/// <summary> /// Initializes a new instance of the <see cref="DefaultDropGenerator" /> class. /// </summary> /// <param name="config">The configuration.</param> /// <param name="randomizer">The randomizer.</param> public DefaultDropGenerator(GameConfiguration config, IRandomizer randomizer) { this.baseGroups = config.BaseDropItemGroups; this.randomizer = randomizer; this.droppableItems = config.Items.Where(i => i.DropsFromMonsters).ToList(); this.ancientItems = this.droppableItems.Where(i => i.PossibleItemSetGroups.Any(o => o.Items.Any(n => n.BonusOption.OptionType == ItemOptionTypes.AncientBonus))).ToList(); }
private async void Window_Loaded(object sender, RoutedEventArgs e) { try { var garcPath = Path.Combine(this.gameDirectory, "RomFS", "a"); var garcCount = Directory.GetFiles(garcPath, "*", SearchOption.AllDirectories).Length; this.game = new GameConfig(garcCount); this.randomizer = Randomizer.GetRandomizer(this.game, this.config); await this.game.Initialize(this.gameDirectory, this.gameLanguage); this.mainPage = new RandomizerPage(this.randomizer); this.Content = this.mainPage; } catch (Exception ex) { MessageBox.Show(this, $"An error occurred while loading the game:\n\n" + $"{ex.Message}", "Error Loading Game", MessageBoxButton.OK, MessageBoxImage.Error); this.Close(); Application.Current.MainWindow?.Show(); } }
public static IEnumerable <T> TakeRandomFrom <T>(this IRandomizer randomizer, IEnumerable <T> source, int count) { var availableCount = source.Count(); if (availableCount == 0) { throw new Exception("Unable to pick random number from empty list"); } if (availableCount == count) { return(source); } var randomElements = new List <T>(); for (var i = 0; i < count; i++) { var random = randomizer.Random(0, availableCount - 1); var randomElement = source.Skip(random).First(); if (randomElements.Contains(randomElement)) { i--; continue; } randomElements.Add(randomElement); } return(randomElements); }
public MDPPerception <TState> Execute(TAction action, IRandomizer r) { MDPPerception <TState> perception = this.MDP.Execute(this.CurrentState, action, r); this.UpdateFromPerception(perception); return(perception); }
public ParticleSet PerceptionUpdate(string perception, IRandomizer r) { // compute Particle Weight foreach (Particle p in particles) { double particleWeight = hmm.SensorModel.Get(p.State, perception); p.Weight = particleWeight; } // weighted sample to create new ParticleSet ParticleSet result = new ParticleSet(hmm); while (result.Count != Count) { foreach (Particle p in particles) { double probability = r.NextDouble(); if (probability <= p.Weight) { if (result.Count < Count) { result.Add(new Particle(p.State, p.Weight)); } } } } return(result); }
public void ProcessMap(Map <T> map, DungeonConfiguration configuration, IRandomizer randomizer) { var isolatedRooms = map.Rooms.Where(room => map.GetCellsAdjacentToRoom(room).All(cell => cell.Terrain == TerrainType.Rock)).ToList(); foreach (var room in map.Rooms) { if (isolatedRooms.Contains(room)) { ConnectRoom(map, randomizer, room, isolatedRooms); } //place doors foreach (var cell in map.GetCellsAdjacentToRoom(room) .Where(cell => cell.Terrain == TerrainType.Floor && map.GetAllAdjacentCells(cell).All(c => c.Terrain != TerrainType.Door))) { //don't place a door if it leads to nowhere if (map.GetAllAdjacentCells(cell).Count(c => c.Terrain == TerrainType.Floor) == 1) { continue; } cell.Terrain = TerrainType.Door; } } }
public Maze Generate(int width, int height, IRandomizer randomizer) { if (width < 3 || height < 3) { throw new ArgumentException("Minimal size of generated maze is 3x3"); } _randomizer = randomizer; _cells = new MazeCellType[width, height]; for (int x = 0; x < _cells.GetLength(0); x++) { for (int y = 0; y < _cells.GetLength(1); y++) { _cells[x, y] = MazeCellType.Wall; } } int startX = _randomizer.GetRandomX(width - 2) + 1; int startY = _randomizer.GetRandomY(height - 2) + 1; _cells[startX, startY] = MazeCellType.Start; CarvePassages(startX, startY); return(Maze.Create(_cells)); }
/// <summary> /// Construct a neural genetic algorithm. /// </summary> /// /// <param name="network">The network to base this on.</param> /// <param name="randomizer">The randomizer used to create this initial population.</param> /// <param name="calculateScore">The score calculation object.</param> /// <param name="populationSize">The population size.</param> /// <param name="mutationPercent">The percent of offspring to mutate.</param> /// <param name="percentToMate">The percent of the population allowed to mate.</param> public NeuralGeneticAlgorithm(BasicNetwork network, IRandomizer randomizer, ICalculateScore calculateScore, int populationSize, double mutationPercent, double percentToMate) : base(TrainingImplementationType.Iterative) { Genetic = new NeuralGeneticAlgorithmHelper { CalculateScore = new GeneticScoreAdapter(calculateScore) }; IPopulation population = new BasicPopulation(populationSize); Genetic.MutationPercent = mutationPercent; Genetic.MatingPopulation = percentToMate * 2; Genetic.PercentToMate = percentToMate; Genetic.Crossover = new Splice(network.Structure.CalculateSize() / 3); Genetic.Mutate = new MutatePerturb(4.0d); Genetic.Population = population; for (int i = 0; i < population.PopulationSize; i++) { var chromosomeNetwork = (BasicNetwork)(network .Clone()); randomizer.Randomize(chromosomeNetwork); var genome = new NeuralGenome(chromosomeNetwork) { GA = Genetic }; Genetic.PerformCalculateScore(genome); Genetic.Population.Add(genome); } population.Sort(); }
/// <summary>Initializes a new instance of the <see cref="MutationGuarder"/> class.</summary> /// <param name="fixer">Handles generic resolution.</param> /// <param name="randomizer">Creates objects and populates them with random values.</param> /// <param name="duplicator">Deep clones objects.</param> /// <param name="asserter">Handles common test scenarios.</param> /// <param name="timeout">How long to wait for methods to complete.</param> internal MutationGuarder(GenericFixer fixer, IRandomizer randomizer, IDuplicator duplicator, Asserter asserter, TimeSpan timeout) : base(fixer, randomizer, timeout) { _duplicator = duplicator ?? throw new ArgumentNullException(nameof(duplicator)); _asserter = asserter ?? throw new ArgumentNullException(nameof(asserter)); }
public virtual void SetUp() { randomizer = Substitute.For <IRandomizer>(); var cup = new Cup(2, randomizer); game = new Game(10, cup); }
public override void Initialize() { InitializeWindowSize(); Randomizer1 = new Randomizer(); Engine = new ParticleEngine(Randomizer1); base.Initialize(); }
public static TransportType GetRandomTransportTypeBetweenCarAndBus(IRandomizer randomizer) { var types = new[] { TransportType.Bus, TransportType.Car }; var index = randomizer.GetRandomNumber(0, types.Length); return(types[index]); }
public void ProcessMap(Map <T> map, DungeonConfiguration configuration, IRandomizer randomizer) { var cellsToRemove = (int)(map.Width * map.Height * configuration.Sparseness); while (cellsToRemove != 0) { //Look at every cell in the maze grid. If the given cell contains a corridor that exits the cell in only one direction //"erase" that cell by removing the corridor var changedCells = new HashSet <T>(); var deadEndCells = map.AllCells.Where(cell => cell.Sides.Values.Count(side => side) == 1).ToList(); if (!deadEndCells.Any()) { break; } foreach (var deadEndCell in deadEndCells) { deadEndCell.IsOpen = false; var openDirection = deadEndCell.Sides.First(pair => pair.Value).Key; deadEndCell.Sides[openDirection] = false; var oppositeCell = map.GetAdjacentCell(deadEndCell, openDirection); oppositeCell.Sides[openDirection.Opposite()] = false; changedCells.Add(deadEndCell); changedCells.Add(oppositeCell); cellsToRemove--; if (cellsToRemove == 0) { break; } } //Repeat step #1 sparseness times } }
/// <summary> /// 난수발생기를 이용하여 <paramref name="values"/> 배열에 난수를 할당합니다. /// </summary> public static void FillValues(this IRandomizer randomizer, double[] values) { randomizer.ShouldNotBeNull("randomizer"); values.ShouldNotBeEmpty("values"); FillValues(randomizer, values, values.Length); }
protected CodeGeneratorBase( CodeGeneratorOptions options = null, IAlphabet alphabet = null, IRandomizer randomizer = null, IUniqueness uniqueness = null, IStopWords stopWords = null, ITransformer transformer = null ) { this.transformer = transformer; this.options = options ?? new CodeGeneratorOptions(); this.alphabet = alphabet ?? new AsciiAlphabet(); this.randomizer = randomizer ?? new RandomRandomizer(); this.uniqueness = uniqueness ?? new NoUniqueness(); this.stopWords = stopWords ?? new NoStopWords(); listeners = new object[] { this.alphabet, this.randomizer, this.uniqueness, this.stopWords } .Where(x => x is IListener) .Cast <IListener>() .ToList(); }
/// <summary> /// Selects a random element of an enumerable. /// </summary> /// <typeparam name="T">The generic type of the enumerable.</typeparam> /// <param name="enumerable">The enumerable.</param> /// <param name="randomizer">The randomizer.</param> /// <returns>The randomly selected element.</returns> public static T SelectRandom <T>(this IEnumerable <T> enumerable, IRandomizer randomizer) { var list = enumerable as IList <T> ?? enumerable.ToList(); var index = randomizer.NextInt(0, list.Count); return(list[index]); }
public ErGraph(int n, double p, IRandomizer r) { throw new Exception("Deprecating this code, adding static factory methods to graph instead YN 9/10/17"); this.N = n; this.p = p; this.random = r; for (int i = 1; i <= n; i++) { AddNode("n" + i); } var nodesList = _nodesDictionary.Values.ToList(); for (int i = 0; i < nodesList.Count; i++) { for (int j = i + 1; j < nodesList.Count; j++) { if (random.GetTrueWithProbability(p)) { AddEdge(nodesList[i], nodesList[j]); } } } }
public SpiceEvaluationContext( string name, SpiceExpressionMode mode, ISpiceNetlistCaseSensitivitySettings caseSetting, IRandomizer randomizer, IExpressionParserFactory expressionParserFactory, IExpressionFeaturesReader expressionFeaturesReader, IExpressionValueProvider expressionValueProvider, INameGenerator nameGenerator, IResultService resultService) : base(name, caseSetting, randomizer, expressionParserFactory, expressionFeaturesReader, expressionValueProvider, nameGenerator, resultService) { Mode = mode; CreateCommonFunctions(); CreateSpiceFunctions(); CreateSpiceParameters(); }
public DroneSupervisor(Map map, IRandomizer randomizer) { _map = map; GoalValue = 0; for (var y = 0; y < map.Size; ++y) GoalValue += map[randomizer.Next(0, map.Size), y]; }
// TODO: make it singleton and IDebugable public int Roll(int count, int diceSides, IRandomizer rnd) { int result = rnd.GetNext(count, diceSides * count + 1); //DoDebugLog(string.Format("Dice roll: {0}d{1} = {2}", count, diceSides, result)); return result; }
/// <summary> /// Complete random roll of random count of random dice type /// </summary> /// <returns></returns> /// <remarks>There will be 1 to 9 rolled dices</remarks> public int Roll(IRandomizer rnd) { int dicesCount = rnd.GetNext(1, 10); string[] numDiceTypes = Enum.GetNames(typeof(Dices)); int selectedDiceIndex = rnd.GetNext(numDiceTypes.Length); Dices selectedDice = (Dices)Enum.Parse(typeof(Dices), numDiceTypes[selectedDiceIndex]); return Roll(dicesCount, selectedDice, rnd); }
public Chip8Cpu(IDisplay display, IRandomizer randomizer, IKeyboard keyboard, IBcdConverter bcdConverter, IInstructionDecoder instructionDecoder, ITimerClock timerClock) { _display = display; _randomizer = randomizer; _keyboard = keyboard; _bcdConverter = bcdConverter; _instructionDecoder = instructionDecoder; _timerClock = timerClock; State = new CpuState(); }
public NeuralGeneticAlgorithm(BasicNetwork network, IRandomizer randomizer, ICalculateScore calculateScore, int populationSize, double mutationPercent, double percentToMate) : base(TrainingImplementationType.Iterative) { NeuralGeneticAlgorithmHelper helper; Label_012F: helper = new NeuralGeneticAlgorithmHelper(); helper.CalculateScore = new GeneticScoreAdapter(calculateScore); this.Genetic = helper; IPopulation population = new BasicPopulation(populationSize); this.Genetic.MutationPercent = mutationPercent; this.Genetic.MatingPopulation = percentToMate * 2.0; this.Genetic.PercentToMate = percentToMate; this.Genetic.Crossover = new Splice(network.Structure.CalculateSize() / 3); this.Genetic.Mutate = new MutatePerturb(4.0); this.Genetic.Population = population; int num = 0; while (true) { NeuralGenome genome2; if (num < population.PopulationSize) { BasicNetwork network2 = (BasicNetwork) network.Clone(); randomizer.Randomize(network2); if ((((uint) percentToMate) + ((uint) populationSize)) >= 0) { genome2 = new NeuralGenome(network2) { GA = this.Genetic }; } } else { population.Sort(); if (((uint) populationSize) <= uint.MaxValue) { return; } goto Label_012F; } if ((((uint) num) + ((uint) populationSize)) >= 0) { NeuralGenome g = genome2; this.Genetic.PerformCalculateScore(g); if (((uint) populationSize) > uint.MaxValue) { goto Label_012F; } this.Genetic.Population.Add(g); num++; } } }
/// <summary> /// Basic constructor /// </summary> /// <param name="network"></param> /// <param name="randomizer"></param> /// <param name="calculateScore"></param> public ParticleSwarmOptimizationAlgorithm(BasicNetwork network,IRandomizer randomizer, ICalculateScore calculateScore) : base(TrainingImplementationType.Iterative) { }
public PEQTestApplication(IEventManager eventMgr, INodes nodes, IRandomizer randomizer, ILocation[] field) { Initialize(eventMgr, nodes, randomizer, field); }
/* / \ * // | \\ * / | \ * | */ public void Initialize(IEventManager eventMgr, INodes nodes, IRandomizer randomizer, ILocation[] field) { this.eventMgr = eventMgr; this.nodes = nodes; this.randomizer = randomizer; if (field is XYDoubleLocation[]) this.field = (XYDoubleLocation[])field; else { isInitialized = false; return; } panelObjsHelper = new PanelObjHelper(panelObjs); this.eventSize = panelObjsHelper.GetDoubleByName("EventSize"); this.eventMeanTime = panelObjsHelper.GetDoubleByName("EventMeanTime"); this.eventFreq = panelObjsHelper.GetDoubleByName("EventFreq"); this.numOccurances = panelObjsHelper.GetIntByName("NumOccurances"); //this.finalEvent = panelObjsHelper.GetBoolByName("FinalEvent"); isInitialized = true; }
public void SetUp() { _sut = new Fluky.Framework.Randomizer(); }
public void Deploy() { if (!isInitialized) throw new InvalidOperationException("RandomDeployer not initialized!"); List<XYDoubleLocation> pointList = new List<XYDoubleLocation>(); rand = randFactory.CreateRandomizer(); bool continueFlag; XYDoubleLocation initial, final, current; initial = (XYDoubleLocation)field[0]; final = (XYDoubleLocation)field[1]; current = new XYDoubleLocation(); // Sink current = new XYDoubleLocation(final.X, (final.Y - initial.Y)/2); current.SetField(field); nodes.AddNode(nodeFactory.CreateNode(current)); pointList.Add(current); nodes.GetNodeByID(0).IsSink = true; // Sources for (int i = 1; i < 6; i++) { current = new XYDoubleLocation(initial.X, (i-1)*(final.Y-initial.Y)/4); current.SetField(field); nodes.AddNode(nodeFactory.CreateNode(current)); pointList.Add(current); } // Node Field for (int i = 6; i < numNodes; i++) { continueFlag = false; while (!continueFlag) { continueFlag = true; current = new XYDoubleLocation( rand.NextDouble() * (final.X - initial.X - 2 * padding) + initial.X + padding, rand.NextDouble() * (final.Y - initial.Y - 2 * padding) + initial.Y + padding); foreach (XYDoubleLocation point in pointList) { if (current.Distance(point) < minDistance) continueFlag = false; } } pointList.Add(current); current.SetField(field); nodes.AddNode(nodeFactory.CreateNode(current)); } }
public void Initialize(IEventManager eventMgr, INodes nodes, IRandomizer randomizer, ILocation[] field) { panelObjsHelper = new PanelObjHelper(panelObjs); this.eventMgr = eventMgr; this.nodes = nodes; this.randomizer = randomizer; this.field = (XYDoubleLocation[])field; this.endTime = panelObjsHelper.GetDoubleByName("EndTime"); }
public Nodes(IRandomizer randomizer) { this.randomizer = randomizer; }
/// <summary> /// Constructor. /// </summary> /// <param name="network">an initialised Encog network. /// The networks in the swarm will be created with /// the same topology as this network.</param> /// <param name="randomizer">any type of Encog network weight initialisation /// object.</param> /// <param name="calculateScore">any type of Encog network scoring/fitness object.</param> /// <param name="populationSize">the swarm size.</param> public NeuralPSO(BasicNetwork network, IRandomizer randomizer, ICalculateScore calculateScore, int populationSize) : base(TrainingImplementationType.Iterative) { // initialisation of the member variables m_populationSize = populationSize; m_randomizer = randomizer; m_calculateScore = calculateScore; m_bestNetwork = network; m_networks = new BasicNetwork[m_populationSize]; m_velocities = null; m_bestVectors = new double[m_populationSize][]; m_bestErrors = new double[m_populationSize]; m_bestVectorIndex = -1; // get a vector from the network. m_bestVector = NetworkCODEC.NetworkToArray(m_bestNetwork); m_va = new VectorAlgebra(); }
public FakeWeatherServiceProvider(IRandomizer randomizer) { _randomizer = randomizer; }
public SimpleMemoryTrainer(IDictionaryStorage storage) { this.storage = storage; this.randomizer = new SimpleRandomizer (this.storage); }
public int Roll(string rollDesc, IRandomizer rnd) { return -1; // TODO: implement parser }
public double EvaluateRandomizer(IRandomizer randomizer, BasicNetwork network, IMLDataSet training) { double total = 0; for (int i = 0; i < SAMPLE_SIZE; i++) { randomizer.Randomize(network); total += Evaluate(network, training); } return total/SAMPLE_SIZE; }
public FQN_RandomDetectionEventGenerator(IEventManager eventMgr, INodes nodes, IRandomizer randomizer, ILocation[] field) { Initialize(eventMgr, nodes, randomizer, field); }
private void InitBlock() { random = Esapi.Randomizer(); }
// /** // * @return the logger // */ // public static ILogger getLogger() { // if (Esapi.logger == null) // return Logger(); // return Esapi.logger; // } // // /** // * @param logger the logger to set // */ // public static void setLogger(ILogger logger) { // Esapi.logger = logger; // } // /// <summary> /// The randomzier accessor. /// </summary> /// <returns> The randomizer implementation. /// </returns> public static IRandomizer Randomizer() { if (Esapi.randomizer == null) Esapi.randomizer = new Randomizer(); return Esapi.randomizer; }
public SimpleMemoryTrainer(IDictionaryStorage storage, IRandomizer randomizer) { this.storage = storage; this.randomizer = randomizer; }
public int Roll(int count, Dices dice, IRandomizer rnd) { return Roll(count, (int)dice, rnd); }
public void SetUp() { _sut = new Randomizer(); }
public Board(IRandomizer randomizer) { _randomizer = randomizer; }