static void Main(string[] args) { int duration = 2200000; duration = 5000; string file = @"Data\Tasks.xml"; string config = @"Data\Config.xml"; string outFile = @"Data\Results"; (Workload work, Configuration cfg)scheme = DataLoader.Load(file, config); Simulation s = HeuristicFactory.Load(scheme.work, scheme.cfg); Console.WriteLine(s); //Simulation s2 = RunSimulatedAnnealing(s, 1500000); List <Simulation> bestSolutions = RunSimulatedAnnealing(s, duration); DataLoader.Unload(outFile, bestSolutions); //Schedule schedule = s2.GetSchedule(); //schedule.Run(); //schedule.Build("schedule.txt", "test.svg"); //Console.Write(schedule.Output); //Console.WriteLine(s2); //Console.WriteLine(s2.Fitness.Score); Console.WriteLine("Hit a key to Exit"); Console.ReadKey(); }
static List <Simulation> RunSimulatedAnnealing(Simulation s, int duration) { SimulatedAnnealing SA = HeuristicFactory.CreateSA(s, duration, SimulatedAnnealingBase.DebugLevel.All); SA.Run(); return(SA.BestSolutions); }
private Dictionary <string, object> GetSetHeuristicsAndOptions(string gameName) { Dictionary <string, object> parameters = new Dictionary <string, object>(); #region RecursionDepth Logger.LogInfo("Setting recursion depth."); uint recursionDepth = (uint)recursionDepthCounter.Value; parameters.Add("recursionDepth", recursionDepth); Logger.LogInfo("Recursion depth set to " + recursionDepth + "."); #endregion #region SetHeuristics Logger.LogInfo("Setting heuristics."); string[] names = new string[0]; double[] weights = new double[0]; switch (gameName) { case "ConnectFour": names = new string[] { "connectFourHeuristic" }; weights = new double[] { 1 }; break; case "TicTacToe": names = new string[] { "ticTacToeHeuristic" }; weights = new double[] { 1 }; break; case "2048": { CheckBox[] selectedHeuristics = GetSelectedCheckBoxesInGroup(setHeuristicsGroupBox); List <string> namesList = selectedHeuristics.OrderBy(checkBox => checkBox.Name) .Select(checkBox => checkBox.Name.Substring(0, checkBox.Name.IndexOf("CheckBox"))) .ToList(); namesList.Add("2048Heuristic"); names = namesList.ToArray(); NumericUpDown[] selectedWeights = GetSelectedNumericUpDownsInGroup(setHeuristicsGroupBox); List <double> weightsList = selectedWeights.OrderBy(numericUpDown => numericUpDown.Name) .Select(numericUpDown => (double)numericUpDown.Value) .ToList(); weightsList.Add(1); weights = weightsList.ToArray(); } break; } Heuristic[] setHeuristics = HeuristicFactory.GetHeuristicsByNames(names, weights); for (int i = 0; i < names.Length; ++i) { Logger.LogInfo("Heuristic " + names[i] + " with weight " + weights[i]); } parameters.Add("setHeuristics", setHeuristics); #endregion return(parameters); }
public IMap DefineMap(DiagonalMovement diagonal, int width, int height, int seed, int minPathLength) { var IsAGoodMap = false; IMap ret = null; var aStar = FinderFactory.GetAStarImplementation(); IHeuristic heuristic; heuristic = diagonal == DiagonalMovement.Never ? HeuristicFactory.GetManhattamImplementation() : HeuristicFactory.GetOctileImplementation(); while (!IsAGoodMap) { var nodes = new List <Node>(); var _map = new Map(diagonal, width, height); var size = Convert.ToInt32((width * height) * (seed / 100M)); var rand = new Random(); while (size > 0) { var p = RandNode(rand, width, height, true); GridMap.Add(p); size--; } _map.DefineAllNodes(GridMap); _map.StartNode = RandNode(rand, width, height, false); _map.EndNode = RandNode(rand, width, height, false); if (!_map.ValidMap()) { throw new Exception("Invalid map configuration"); } if (aStar.Find(_map, heuristic)) // verifica se o mapa possui um caminho { var path = _map.GetPath(); if (path.Max(e => e.G) >= minPathLength) // verifica se o caminho sastifaz o tamanho minimo { IsAGoodMap = true; ret = _map; } } GridMap = new List <Node>(); } ret.Clear(); ret.MapType = MapGeneratorEnum.Random; return(ret); }
public void StratPathFindinAlgorithm() { pathFind.interactable = false; resetCurrentPath.interactable = true; clearAll.interactable = true; gridController.PathGridState = PathGridState.PathFind; gridController.InitGraf(); Vector2Int goalPosition = new Vector2Int(gridController.GoalPos.x, gridController.GoalPos.y); Vector2Int startPosition = new Vector2Int(gridController.StartPos.x, gridController.StartPos.y); IHeuristicEstimate heuristic = HeuristicFactory.СreateHeuristic(heuristicType, breakerType, startPosition, float.Parse(heuristicCoeffField.text)); float timeDelay = float.Parse(delayBeforeSteps.text); AStarAlgorithm algorithm = new AStarAlgorithm(gridMarkerController, heuristic, timeDelay); pathFindingAlgorithmCoroutine = StartCoroutine(algorithm.FindPath(gridController.GetStartVertex(), gridController.GetGoalVertex())); }
public void StratPathFindinAlgorithm() { OnPathSearchState(); gridController.InitGraf(); Vector2Int goalPosition = new Vector2Int(gridController.GoalPos.x, gridController.GoalPos.y); Vector2Int startPosition = new Vector2Int(gridController.StartPos.x, gridController.StartPos.y); IHeuristicEstimate heuristic = HeuristicFactory.СreateHeuristic(HeuristicType.Manhattan, TieBreakerType.None, startPosition, 1); float timeDelay = float.Parse(delayBeforeSteps.text); float moveTimeDelay = float.Parse(delayBeforeMove.text); DStarLiteAlgorithm algorithm = new DStarLiteAlgorithm(gridMarkerController, gridController.Graph, heuristic, timeDelay); gridController.OnVerteciesUpdate = (vertecies) => { vertecies.ForEach(v => algorithm.UpdatePath(v)); }; pathFindingAlgorithmCoroutine = StartCoroutine(algorithm.MoveByPath(gridController.GetStartVertex(), gridController.GetGoalVertex(), OnPathSearchState, OnStartMove)); }
private Dictionary <string, object> GetDynamicHeuristicOptions(string dynamicHeuristicName) { Dictionary <string, object> parameters = new Dictionary <string, object>(); Logger.LogInfo("Setting recursion depth."); uint recursionDepth = (uint)recursionDepthCounter.Value; parameters.Add("recursionDepth", recursionDepth); Logger.LogInfo("Recursion depth set to " + recursionDepth + "."); Logger.LogInfo("Setting dynamic heuristic."); string filename = dynamicHeuristicsFilePath + GetGameName() + "\\" + dynamicHeuristicName + "\\" + recursionDepth; int numberOfInputs = GetNumberOfInputs(); Heuristic heuristic = HeuristicFactory.GetHeuristicByName(dynamicHeuristicName, 1, new Dictionary <string, object>() { { "filename", filename }, { "numberOfInputs", numberOfInputs }, { "gameName", GetGameName() } }); parameters.Add("dynamicHeuristic", heuristic); return(parameters); }
/// <summary> /// Returns an algorithm based on the given string and the given data /// fields. This will throw an AlgorithmNotFoundException if the given /// key is invalid based on the given implementation of this interface. /// </summary> /// <param name="Key">A string key of the algorithm which should be /// selected.</param> /// <param name="Params">object params of additional optional data /// to use when fetching the algorithm. What this data means depends /// on the implementation.</param> /// <returns></returns> public Algorithm <SS, DS> GetAlgorithm(string Key, HeuristicFactory <SS, DS> HeuristicFactory, int offset, params string[] Data) { if (RealTimeDataSet) { int i; if ((i = Key.IndexOf("-Weight=")) > 0) { string AfterValue = Key.Substring(i + 8); int j = AfterValue.IndexOf("-"); if (j > 0) { AfterValue = AfterValue.Substring(0, j); } Weight = new Metric(double.Parse(AfterValue)); if (j > 0) { AfterValue = Key.Substring(i + 8 + j); Key = Key.Substring(0, i) + AfterValue; } else { Key = Key.Substring(0, i); } } else if ((i = Key.IndexOf("-Ratio=")) > 0) { string AfterValue = Key.Substring(i + 7); int j = AfterValue.IndexOf("-"); if (j > 0) { AfterValue = AfterValue.Substring(0, j); } Ratio = double.Parse(AfterValue); if (j > 0) { AfterValue = Key.Substring(i + 7 + j); Key = Key.Substring(0, i) + AfterValue; } else { Key = Key.Substring(0, i); } } } try { if (Key.Equals("Human")) { return(new Human(vis as OpenGLStateVisualizer) as Algorithm <SS, DS>); } else if (Key.Equals("NoOp")) { return(new NoOp <SS, DS>( )); // Some Special Algs. for myself. } else if (Key.Equals("depth-first-closed-list")) { return(new DepthFirstSearch <SS, DS>(Metric.Zero, true, vis)); } else if (Key.Equals("depth-first-closed-list-bounded")) { return(new DepthFirstSearch <SS, DS>(new Metric(double.Parse(Data[offset])), true, vis)); } else if (Key.Equals("depth-first-duplicate-detection")) { return(new DepthFirstSearch <SS, DS>(Metric.Zero, false, vis)); } else if (Key.Equals("depth-first-duplicate-detection-bounded")) { return(new DepthFirstSearch <SS, DS>(new Metric(double.Parse(Data[offset])), false, vis)); /*} else if ( Key.Equals( "depth-first-id-closed-list" ) ) { * return new IterativeDeepingSearch<SS, DS>( * new DepthFirstSearch<SS, DS>( new Metric( 1.0d ), true, vis ) ); * } else if ( Key.Equals( "depth-first-id-duplicate-detection" ) ) { * return new IterativeDeepingSearch<SS, DS>( * new DepthFirstSearch<SS, DS>( new Metric( 1.0d ), false, vis ) ); */ } // Start A1 Algs. else if (Key.Equals("depth-first")) { return(new DepthFirstSearch <SS, DS>(Metric.Zero, true, vis)); } /*else if ( Key.Equals( "depth-first-id" ) ) { * return new IterativeDeepingSearch<SS, DS>( * new DepthFirstSearch<SS, DS>( new Metric( 1.0d ), false, vis ) ); * } */ else if (Key.Equals("uniform-cost")) { return(new UniformedCostSearch <SS, DS>(true, vis)); } else if (Key.Equals("greedy")) { return(new Greedy <SS, DS>(h, true, vis)); } else if (Key.Equals("A*")) { return(new Net.Mokon.Edu.Unh.CS.AI.Search.Algorithms.AStar <SS, DS>( h, true, vis)); } else if (Key.Equals("weighted-a-star")) { return(new WeightedAStar <SS, DS>( HeuristicFactory.GetHeuristic(Data[offset + 1]), true, new Metric(double.Parse(Data[offset])), vis)); } else if (Key.Equals("weighted-a-star-duplicate-detection")) { return(new WeightedAStar <SS, DS>( HeuristicFactory.GetHeuristic(Data[offset + 1]), false, new Metric(double.Parse(Data[offset])), vis)); } /*else if ( Key.Equals( "ida-star" ) ) { * return new IterativeDeepingSearch<SS, DS>( * new Net.Mokon.Edu.Unh.CS.AI.Search.Algorithms.AStar<SS, DS>( * new PathLengthGComputer<SS, DS>( ), * HeuristicFactory.GetHeuristic( Data[1] ), new Metric( 1.0d ), true, vis ) ); * // Real Time Algorithms * } else if ( Key.Equals( "LRTA*" ) ) { * return new LRTAStar<SS, DS>( h, true, vis, Weight, false ); * } else if ( Key.Equals( "LRTA*-dyn" ) ) { * return new LRTAStar<SS, DS>( h, false, vis, Weight, false ); * } else if ( Key.Equals( "RTA*" ) ) { * return new LRTAStar<SS, DS>( h, true, vis, Weight, true ); * } else if ( Key.Equals( "RTA*-dyn" ) ) { * return new LRTAStar<SS, DS>( h, false, vis, Weight, true ); * } */ else if (Key.Equals("D*Lite")) { return(new DStarLite <SS, DS>(h, sut, vis)); } else if (Key.Equals("Anytime-D*")) { return(new AnytimeDStar <SS, DS>(h, sut, vis)); } else if (Key.Equals("LSS-LRTA*")) { return(new LSSLRTAStar <SS, DS>(h, vis, sut)); } else if (Key.Equals("A*-RealTime")) { return(new Net.Mokon.Edu.Unh.CS.AI.Search.Algorithms.RealTime. AStar <SS, DS>(h)); } else if (Key.StartsWith("RealTimeD*Lite")) { ChooseMethodLandMarkGoal lmg = ChooseMethodLandMarkGoal.Goal; ChooseMethodFilterSucc fs = ChooseMethodFilterSucc.All; ChooseMethodStep step = ChooseMethodStep.MinHLandmarkGoal; if (Key.Contains("LSS-LRTA*")) // must be b4 lrta* { step = ChooseMethodStep.LSSLRTAStar; } else if (Key.Contains("LRTA*")) { step = ChooseMethodStep.LRTAStar; } else if (Key.Contains("RTA*")) { step = ChooseMethodStep.RTAStar; } else if (Key.Contains("AStar")) { step = ChooseMethodStep.AStar; } else if (Key.Contains("NoOp")) { step = ChooseMethodStep.Null; } else if (Key.Contains("Adjusted")) { step = ChooseMethodStep.MinHAdustedLandmarkGoal; } if (Key.Contains("Goal")) { lmg = ChooseMethodLandMarkGoal.Goal; } else if (Key.Contains("USample")) { lmg = ChooseMethodLandMarkGoal.USample; } else if (Key.Contains("UTop")) { lmg = ChooseMethodLandMarkGoal.UTop; } if (Key.Contains("Lock")) { fs = ChooseMethodFilterSucc.Lock; } return(new RealTimeDStarLite <SS, DS>(h, sut, vis, lmg, fs, step, Weight, Ratio)); } else if (Key.StartsWith("RealTimeAnytimeD*")) { ChooseMethodStep step = ChooseMethodStep.LSSLRTAStar; if (Key.Contains("LSS-LRTA*")) // must be b4 lrta* { step = ChooseMethodStep.LSSLRTAStar; } else if (Key.Contains("LRTA*")) { step = ChooseMethodStep.LRTAStar; } else if (Key.Contains("RTA*")) { step = ChooseMethodStep.RTAStar; } else if (Key.Contains("NoOp")) { step = ChooseMethodStep.Null; } return(new RealTimeAnytimeDStar <SS, DS>(h, sut, vis, step, Ratio)); } else if (Key.Equals("BRTA*")) { return(new BRTSAStar <SS, DS>(h, sut)); } else if (Key.Equals("BRTwA*")) { return(new BRTSwAStar <SS, DS>(h, sut, Weight)); /*} else if ( Key.Equals( "TBA*-Old" ) ) { * return new TBAStar<SS, DS>( ( SS, DS, G, Os ) => gc.G( SS, DS, G ) + h.H( SS, DS, G, Os ) ); * } else if ( Key.Equals( "TBA*" ) ) { * return new TBAStar2<SS, DS>( ( SS, DS, G, Os ) => gc.G( SS, DS, G ) + h.H( SS, DS, G, Os ), 0.9f, 10 ); * } else if ( Key.Equals( "TBA*-LPA*" ) ) { * return new TBAStar2<SS, DS>( h, sut, 0.9f, 10, vis ); * } else if ( Key.StartsWith( "RealTimeTBA*-LPA*" ) ) { * ReconstructPathStartingPoint rpsp = ReconstructPathStartingPoint.UTop; * ShortcutDetection sd = ShortcutDetection.None; * * if ( Key.Contains( "-UTop" ) ) { * rpsp = ReconstructPathStartingPoint.UTop; * } else if ( Key.Contains( "-BestH" ) ) { * rpsp = ReconstructPathStartingPoint.BestH; * } else if ( Key.Contains( "-Alternate" ) ) { * rpsp = ReconstructPathStartingPoint.Alternate; * } * * if ( Key.Contains( "-ShortcutDetection" ) ) { * sd = ShortcutDetection.AStar; * } * * return new RealTimeTBAStar<SS, DS>( h, sut, 0.9f, 10, vis, rpsp, sd );*/ } else if (Key.Equals("BRTA*Sorting")) { return(new BRTSAStarSorting <SS, DS>(h, sut)); } else if (Key.Equals("LPA*")) { return(new LPAStar <SS, DS>(h, sut, vis, ReconstructPathStartingPoint.UTop)); } else if (Key.Equals("")) { return(null); } else { throw new AlgorithmNotFoundException( "Algorithm [ " + Key + " ] Not Implemented"); } } catch (FormatException) { throw new AlgorithmNotFoundException( "Algorithm [ " + Key + " ] Problem Parsing Arguments"); } }
static void Process(BatchOption option) { var ft = new FileTool(); var now = DateTime.Now; var folder = option.Directory; var dataFile = "_data.csv"; var dataFileGA = "_dataGA.csv"; var files = Directory.GetFiles(folder, "*.txt"); var fileCount = files.Count(); var finders = option.Finder.ToArray(); var heuristics = option.Heuristic.ToArray(); var Mutation = option.Mutate.ToArray(); var Crossover = option.Crossover.ToArray(); var Fitness = option.Fitness.ToArray(); var Selection = option.Selection.Cast <SelectionEnum>().ToArray(); var newdatafile = !File.Exists(dataFile); var newdatafileGA = !File.Exists(dataFileGA); StreamWriter csvFile; StreamWriter csvGAFile; if (newdatafile) { csvFile = File.CreateText(dataFile); } else { csvFile = File.AppendText(dataFile); } if (newdatafileGA) { csvGAFile = File.CreateText(dataFileGA); } else { csvGAFile = File.AppendText(dataFileGA); } //csvFile = new StreamWriter(File.Open(dataFile, FileMode.OpenOrCreate), Encoding.UTF8, 4096, false); //csvGAFile = new StreamWriter(File.Open(dataFileGA, FileMode.OpenOrCreate), Encoding.UTF8, 4096, false); if (newdatafile) { csvFile.Write(new TextWrapper().GetHeader()); } if (newdatafileGA) { csvGAFile.Write(new TextGAWrapper().GetHeader()); } for (int i = 0; i < fileCount; i++) { var map = FileTool.ReadMapFromFile(files[i]); foreach (var _finder in finders) { foreach (var _h in heuristics) { var h = new HeuristicFactory().GetImplementation(_h); var finder = new FinderFactory().GetImplementation(_finder); if (finder is IGeneticAlgorithm) { for (int cross = 0; cross < Crossover.Count(); cross++) { for (int mut = 0; mut < Mutation.Count(); mut++) { for (int fit = 0; fit < Fitness.Count(); fit++) { for (int sel = 0; sel < Selection.Count(); sel++) { for (int j = 0; j < option.GaTimes; j++) { GC.Collect(); GC.WaitForPendingFinalizers(); var GAFinder = (IGeneticAlgorithm) new FinderFactory().GetImplementation(_finder); GAFinder.Crossover = new CrossoverFactory().GetImplementation(Crossover[cross]); GAFinder.Mutate = new MutateFactory().GetImplementation(Mutation[mut]); GAFinder.Fitness = new FitnessFactory().GetImplementation(Fitness[fit]); GAFinder.Selection = new SelectionFactory().GetImplementation(Selection[sel]); var helper = $"\n n:{j},cx:{GAFinder.Crossover.GetType().Name},m:{GAFinder.Mutate.GetType().Name},f:{GAFinder.Fitness.GetType().Name},s:{GAFinder.Selection.GetType().Name}"; var csv = new TextWrapper(); csv = RunStep(csv, i, fileCount, map, h, GAFinder, option.Directory, Path.GetFileName(files[i]), helper); csvFile.Write(csv.ToString()); var csvGA = new TextGAWrapper { Alg = csv.Alg, MapNumber = csv.MapNumber, Heuristic = csv.Heuristic, MapTypeGenerate = csv.MapTypeGenerate, MapDiagonal = csv.MapDiagonal, MapSize = csv.MapSize, Solution = csv.Solution, Time = csv.Time, MaxNodes = csv.MaxNodes, PathLength = csv.PathLength, Crossover = GAFinder.Crossover.GetType().Name, Mutation = GAFinder.Mutate.GetType().Name, Fitness = GAFinder.Fitness.GetType().Name, Selection = GAFinder.Selection.GetType().Name, Generations = GAFinder.Generations.ToString(), }; csvGAFile.Write(csvGA.ToString()); } } } } } } else { var csv = new TextWrapper(); csv = RunStep(csv, i, fileCount, map, h, finder, option.Directory, Path.GetFileName(files[i])); csvFile.Write(csv.ToString()); } csvFile.Flush(); csvGAFile.Flush(); } } } DrawTextProgressBar(fileCount, fileCount); csvFile.Dispose(); csvGAFile.Dispose(); }
public IMap DefineMap(DiagonalMovement diagonal, int width, int height, int seed, int minPathLength) { int _GDC(int a, int b) => (b == 0 || a == 0) ? a | b : _GDC(Min(a, b), Max(a, b) % Min(a, b)); var blocksize = Blocksize > 0 ? Blocksize : _GDC(width, height); var IsAGoodMap = false; IMap ret = null; // finder para valida se o mapa é passavel var aStar = FinderFactory.GetAStarImplementation(); IHeuristic heuristic; heuristic = diagonal == DiagonalMovement.Never ? HeuristicFactory.GetManhattamImplementation() : HeuristicFactory.GetOctileImplementation(); var subgrid = new List <Node>(); while (!IsAGoodMap) { var nodes = new List <Node>(); var _map = new Map(diagonal, width, height); var size = Convert.ToInt32(blocksize * blocksize * (seed / 100M)); var rand = new Random(); while (size > 0) { var p = RandNode(rand, blocksize, blocksize, true); subgrid.Add(p); size--; } for (int i = 0; i < width; i += blocksize) { for (int j = 0; j < height; j += blocksize) { foreach (var item in subgrid) { var x = item.X + i; var y = item.Y + j; if (x < width && y < height) { var node = new Node(x, y, false); GridMap.Add(node); } } } } _map.DefineAllNodes(GridMap); _map.StartNode = RandNode(rand, width, height, false); _map.EndNode = RandNode(rand, width, height, false); if (!_map.ValidMap()) { throw new Exception("Invalid map configuration"); } if (aStar.Find(_map, heuristic)) // verifica se o mapa possui um caminho { var path = _map.GetPath(); if (path.Max(e => e.G) >= minPathLength) // verifica se o caminho sastifaz o tamanho minimo { IsAGoodMap = true; _map.Clear(); ret = _map; } } GridMap = new List <Node>(); subgrid = new List <Node>(); } ret.Clear(); ret.MapType = MapGeneratorEnum.WithPattern; return(ret); }