private Graph.Graph CreateGraph() { Graph.Graph graph = new Graph.Graph(); graph.Places.AddRange(_places); graph.ChosenPlaces.AddRange(_places); return(graph); }
public override bool Execute(AccessibleQueryStatement query, Graph.Graph graph, HistoryStatement history) { if (graph == null) { throw new ArgumentNullException(nameof(graph)); } query.StateFromCondition = query.StateFromCondition ?? graph.GetStartCondition(history); var startVertices = graph.Vertexes.FindVerticesSatisfyingCondition(query.StateFromCondition).ToList(); startVertices = BuildGraph(startVertices, graph, history).ToList(); switch (query.Sufficiency) { case Sufficiency.Necessary: return(ExecuteNecessarySufficiency(startVertices, query.StateToCondition)); case Sufficiency.Possibly: return(ExecutePossiblySufficiency(startVertices, query.StateToCondition)); case Sufficiency.Typically: return(ExecuteTypicallySufficiency(startVertices, query.StateToCondition)); default: throw new InvalidOperationException(); } return(false); }
public DijkstraAlgorithm(Graph.Graph g) { this.g = g; priority = new PriorityQueue <double, string>(); ShortestPathNodes = new List <INode>(); marked = new Dictionary <string, string>(); }
/// <summary> /// Возвращает список всех путей от одной вершины до другой /// </summary> /// <param name="graph">Граф</param> /// <param name="start">Имя начальной вершина</param> /// <param name="end">Имя конечной вершина</param> /// <returns>Список путей; путь - список вершин</returns> public IReadOnlyList <IReadOnlyList <Vertex> > FindAllPathes(Graph.Graph graph, string start, string end) { Vertex startVertex = graph.GetVertex(start); Vertex endVertex = graph.GetVertex(end); return(FindAllPathes(graph, startVertex, endVertex)); }
static void Main(string[] args) { /*int[,] matrix = { * { 0, 1, 0, 0, 0, 1, 1}, * { 1, 0, 0, 1, 1, 1, 0}, * { 0, 0, 0, 1, 0, 0, 1}, * { 0, 1, 1, 0, 1, 0, 0}, * { 0, 1, 0, 1, 0, 0, 0}, * { 1, 1, 0, 0, 0, 0, 0}, * { 1, 0, 1, 0, 0, 0, 0} * }; */ int[,] matrix = { { 0, 1, 0, 0, 0, 1, 1 }, { 1, 0, 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0 }, { 1, 1, 0, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0 } }; Graph.Graph graph = new Graph.Graph(matrix); graph.BreadthTraversal(Console.WriteLine); }
public void AStarSameOriginAndDestination() { bool error = false; try { var list = CreatePointList(); Graph.Graph <GameObject> graph = new Graph.Graph <GameObject>(); graph.AddNodes(list); int[] indices = new int[graph.Nodes.Count * 2]; for (int i = 0; i < graph.Nodes.Count * 2; i += 2) { indices[i] = Random.Range(0, graph.Nodes.Count); indices[i + 1] = Random.Range(0, graph.Nodes.Count); } graph.CreateEdges(indices, (c, d) => Vector3.Distance(c.transform.position, d.transform.position)); graph.CalculateHeuristics(graph.Nodes[0].Item, (c, d) => Vector3.Distance(c.transform.position, d.transform.position)); var path = graph.AStar(0, 0); } catch { error = true; } Assert.IsFalse(error); }
private static void AddChosenPlaces(Graph.Graph graph, bool isGiven = false) { if (isGiven) { foreach (var ln in _data3) { List <String> id = ln.Split("|").ToList(); Place place = graph.Places.Find(item => item.Id.Equals(id[1].Replace(" ", ""))); if (graph.ChosenPlaces.Exists(item => item.Equals(place))) { throw new IOException($"Cannot choose place twice {ln}"); } if (place == null) { throw new IOException($"Cannot choose place that not exist {ln}"); } graph.AddChosenPlace(place); } } else { graph.ChosenPlaces.AddRange(graph.Places); } }
public Tensor[] Step(Graph.Graph f, Tensor[] x, bool reverse = false) { var res = new Tensor[x.Length]; var cells = new Tensor[x.Length]; var c = new Tensor(1, _bc.Col, true); var h = new Tensor(1, _bo.Col, true); if (reverse) { for (var i = x.Length - 1; i >= 0; i--) { res[i] = Step(f, x[i], c, h, out cells[i]); h = res[i]; c = cells[i]; } } else { for (var i = 0; i < x.Length; i++) { res[i] = Step(f, x[i], c, h, out cells[i]); h = res[i]; c = cells[i]; } } return(res); }
/// <summary> /// Implementation of a BFS algorithm for a given starting node. /// This doesn't work with a destination node, but rather returns /// the whole "reachability graph". /// </summary> /// <param name="startingNode">The node from which to get the reachability graph</param> /// <returns>The reachability graph from the node given</returns> private Graph.Graph Bfs(INode startingNode) { var visited = new Dictionary <INode, bool>(); var queue = new Queue <INode>(); visited[startingNode] = true; var graph = new Graph.Graph(); queue.Enqueue(startingNode); while (queue.Count > 0) { var node = queue.Dequeue(); graph.AddNode(node); graph.AddEdges(node.GetOutwardsEdges()); foreach (var child in node.GetChilds()) { if (child == null) { continue; } if (visited.ContainsKey(child)) { continue; } queue.Enqueue(child); visited[child] = true; } } return(graph); }
void Start() { // Load the graph.. string filePath = Application.streamingAssetsPath + "/Examples/NewWorld.json"; Graph.Graph graph = Launcher.Instance.LoadGraph(filePath); if (graph == null) { Log.Error("Can not find graph file " + filePath); return; } // Get the chunk generator node.. graph.ForceUpdateNodes(); _chunkGenerator = (ChunkGeneratorNode)graph.GetFirstNodeWithType(typeof(ChunkGeneratorNode)); if (_chunkGenerator == null) { Log.Error("Can not find a chunk generator node in the graph."); } // Get the main camera. _camera = GameObject.Find("Main Camera"); if (_camera == null) { Log.Error("Can not camera with the name 'Main Camera'."); return; } _camera.AddComponent <KeyboardControls>(); }
private static IEnumerable <Vertex> ApplyNotInitiallyValueStatements(Graph.Graph graph, HistoryStatement history, IEnumerable <Vertex> vertices) { foreach (var val in history.Values.Where(x => x.Actions.Count != 0)) { var valuePaths = vertices.SelectMany(x => x.EdgesOutgoing); for (int i = 0; i < val.Actions.Count - 1; i++) { // wybranie wszystkich krawędzi odpowiadajacych danej parze (actor, action) z value staatement valuePaths = valuePaths.Where(y => y.Action == val.Actions[i].Action && y.Actor == val.Actions[i].Agent).Select(x => x.To) .SelectMany(x => x.EdgesOutgoing); if (valuePaths.Count() == 0) { break; } } // krawędzie spełniajace warunek ostatniej pary (actor, action) z value staatement valuePaths = valuePaths.Where(y => y.Action == val.Actions[val.Actions.Count - 1].Action && y.Actor == val.Actions[val.Actions.Count - 1].Agent); var edgeList = valuePaths.ToList(); for (int i = 0; i < edgeList.Count; i++) { // znalezienie wierzchołka, do którego przeniesiemy się po zaaplikowaniu value statements var vertexState = edgeList[i].To.State.Values.ToDictionary(x => x.Key, x => x.Value); foreach (var fluent in val.Condition.ExtractFluentsValues()) { vertexState[fluent.Key] = fluent.Value; } var vertexEvaluatingValueStatement = graph.Vertexes.Where(v => v.State.Values.All(x => vertexState[x.Key] == x.Value)).ToList(); if (vertexEvaluatingValueStatement.Count > 1) { throw new InvalidOperationException("vertexEvaluatingValueStatement length is grater than 1."); } // sprawdzić czy wszystkie drogi prowadzące do wierzchołka spełniają value statement // TODO if (edgeList[i].To.EdgesIncoming.All(x => valuePaths.Contains(x)) && val.IsObservable == false) { edgeList[i].To = vertexEvaluatingValueStatement.First(); } else { vertexEvaluatingValueStatement.ForEach( x => { var actionEdge = edgeList[i].From.EdgesOutgoing.FirstOrDefault( y => y.IsTypical == edgeList[i].IsTypical && edgeList[i].Action == y.Action && edgeList[i].Actor == y.Actor); if (actionEdge == null) { edgeList[i].From.EdgesOutgoing.Add(new Edge(edgeList[i].From, x, edgeList[i].IsTypical, edgeList[i].Action, edgeList[i].Actor)); } else { actionEdge.To = x; } }); } } } return(vertices); }
public void FindNoPathTest() { Graph.Graph graph = CreateGraph(); Dijkstra dijkstra = new Dijkstra(graph); Path path = dijkstra.FindPath(_places[0], _places[0]); Assert.Null(path); }
public Genetic(int generationNumber, int populationSize, Graph.Graph graph) { _graph = graph; _random = new Random(); _allPaths = new AllPaths(graph); _generationNumber = generationNumber; _populationSize = populationSize; }
private static void AddPlace(Graph.Graph graph) { foreach (var ln in _data1) { List <String> data = ln.Split("|").ToList(); graph.AddPlace(new Place((data[1].Replace(" ", "")), data[2])); } }
public static String RelayGraphProperties(Graph.Graph g) { StringBuilder sb = new StringBuilder(); sb.Append("The Graph shown " + g.LABEL); sb.Append(" has " + g.AllEdges.Count.ToString() + " total edges and " + g.AllNodes.Count.ToString() + " total nodes. "); return(sb.ToString()); }
public DashboardItem(int id, int column, int row, int x_Size, int y_Size, Graph.Graph graph) { Id = id; Column = column; Row = row; X_Size = x_Size; Y_Size = y_Size; Graph = graph; }
private void UpdateGenUnitsGraphIndex(Graph.Graph graph, int newId) { var list = GetGenUnitsOnGraph(graph); foreach (var genUnit in list) { genUnit.Graphid = newId; } }
/// <summary> /// Adds the specified road to this map. This also modifies the underlying graph structures /// </summary> /// <param name="road"></param> public void AddRoad(Road road) { mRoads.AddLast(road); // first check if two graphs got connected. // because we need to differ between road connected two graphs, or road was added to one graph only if (((PlatformBlank)road.GetChild()).Friendly && ((PlatformBlank)road.GetParent()).Friendly) { if (mPlatformToGraphId[(PlatformBlank)road.GetChild()] != mPlatformToGraphId[(PlatformBlank)road.GetParent()]) { var childIndex = mPlatformToGraphId[(PlatformBlank)road.GetChild()]; var parentIndex = mPlatformToGraphId[(PlatformBlank)road.GetParent()]; // since the graphes will get connected by this road, we first // get all the nodes and edges from both graphes var connectGraphNodes = mGraphIdToGraph[childIndex].GetNodes() .Concat(mGraphIdToGraph[parentIndex].GetNodes()).ToList(); var connectGraphEdges = mGraphIdToGraph[childIndex].GetEdges() .Concat(mGraphIdToGraph[parentIndex].GetEdges()).ToList(); // don't forget to add the current road to the graph aswell connectGraphEdges.Add(road); foreach (var node in connectGraphNodes) { // now we update our dictionary, such that all nodes formerly in the graph // of the node road.GetChild() are now in the parent nodes graph. // this is "arbitrary", we could also do it the other way around mPlatformToGraphId[(PlatformBlank)node] = parentIndex; ((PlatformBlank)node).SetGraphIndex(parentIndex); } // now we create the actual connected graph var graph = new Graph.Graph(connectGraphNodes, connectGraphEdges); // the only thing left is to update the two former graph references // and add the new graph mGraphIdToGraph[childIndex] = null; mGraphIdToGraph[parentIndex] = graph; UpdateGenUnitsGraphIndex(mGraphIdToGraph[parentIndex], parentIndex); mGraphIdToEnergyLevel[childIndex] = 0; mDirector.GetDistributionDirector.MergeManagers(childIndex, parentIndex, parentIndex); mDirector.GetPathManager.RemoveGraph(childIndex); mDirector.GetPathManager.AddGraph(parentIndex, graph); return; } // the road was in the same graph, thus just add it to the graph mGraphIdToGraph[mPlatformToGraphId[(PlatformBlank)road.GetChild()]].AddEdge(road); } }
public IAlgorithm<IList<IVertex>> GetAlgorithm(Parameters parameters) { var antFactory = new AntFactory(); var prober = new Prober(parameters.Alpha, parameters.Betta); IGraph graph = new Graph.Graph(parameters.Matrix); var algorithm = new GreedyAlgorithm(antFactory, prober, parameters.IterationsWithoutChanges, parameters.Iterations, parameters.EvaporationRate, parameters.DefaultPheromone, parameters.GreedyRate, graph, parameters.Q); return algorithm; }
public static GraphEdgeBinaryChromosome CreateRandom(Graph.Graph graph, IRandomization randomization) { IEnumerable <EdgeBinaryGene> genes = graph.Edges.Select(e => new EdgeBinaryGene(randomization.NextBoolean(), e)) .ToList(); Graph.Graph chromosomeGraph = new Graph.Graph(graph.Vertices, genes.Where(g => g.Value).Select(g => g.Edge)); return(new GraphEdgeBinaryChromosome(genes, chromosomeGraph.GetConnectedComponents())); }
public Map(int mapSize) { //TODO: randomize choice of rooms String[] files = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory + "Levels\\", "*.cmap"); generateMap(files, this, mapSize); state = MapState.Enter; UIManager.Instance.Fade = true; graph = new Graph.Graph(mapSize * mapSize, 64, 64); }
public void DoesNotAllowDuplicates() { var list = CreatePointList(); list.Add(list[0]); Graph.Graph <GameObject> graph = new Graph.Graph <GameObject>(); graph.AddNodes(list); Assert.IsTrue(graph.FindAllNodes(n => n.Item == list[0]).Count == 1); }
// i(t) = sigmoid(W(i)*x(t) + U(i)*h(t-1)) input gate // f(t) = sigmoid(W(f)*x(t) + U(f)*h(t-1)) forget gate // o(t) = sigmoid(W(o)*x(t) + U(o)*h(t-1)) output exposure gate // c tilde(t) = tanh(W(c)*x(t) + U(c)*h(t-1)) new memory cell // c(t) = f(t).*c tilde(t-1) + i(t).*c tilde(t) final memory cell // h(t) = o(t).*tanh(c(t)) public Tensor Step(Graph.Graph f, Tensor x, Tensor h) { // input gate var inputGate = f.Sigmoid(f.AddBias(f.Add(f.Multiply(x, _wix), f.Multiply(h, _wih)), _bi)); // forget gate var forgetGate = f.Sigmoid(f.AddBias(f.Add(f.Multiply(x, _wfx), f.Multiply(h, _wfh)), _bf)); var newInput = f.Tanh(f.Multiply(x, _wcx)); return(f.Add(f.ElementwiseMultiply(inputGate, newInput), f.ElementwiseMultiply(forgetGate, f.Tanh(h)))); }
void Start() { // create the graph Graph.Graph graph = new Graph.Graph(); // create an operator node var operator01 = (NumberOperatorNode)graph.CreateNode <NumberOperatorNode>(); operator01.X = 200; operator01.Y = 40; operator01.SetMode(Operator.Add); graph.AddNode(operator01); // create a display node var diplay01 = (NumberDisplayNode)graph.CreateNode <NumberDisplayNode>(); diplay01.X = 330; diplay01.Y = 80; graph.AddNode(diplay01); // link the nodes graph.Link( (InputSocket)diplay01.GetSocket(typeof(INumberConnection), typeof(InputSocket), 0), (OutputSocket)operator01.GetSocket(typeof(INumberConnection), typeof(OutputSocket), 0)); // cerate a perlin noise node var perlinNoise = graph.CreateNode <UnityPerlinNoiseNode>(); perlinNoise.X = 80; perlinNoise.Y = 250; graph.AddNode(perlinNoise); // create a display map node var displayMap = graph.CreateNode <DisplayMapNode>(); displayMap.X = 300; displayMap.Y = 280; graph.AddNode(displayMap); // link the nodes graph.Link( (InputSocket)displayMap.GetSocket(typeof(INumberConnection), typeof(InputSocket), 0), (OutputSocket)perlinNoise.GetSocket(typeof(INumberConnection), typeof(OutputSocket), 0)); // to test the serialization... // create a json out of the graph var serializedJSON = graph.ToJson(); // dezeiralize the json back to a graph var deserializedGraph = Graph.Graph.FromJson(serializedJSON); // add the graph to the launcher to see it in the editor. Launcher.Instance.AddGraph(deserializedGraph); }
private Graph.Graph CreateGraph() { Graph.Graph graph = new Graph.Graph(); graph.Places.AddRange(_places); graph.ChosenPlaces.AddRange(_places); graph.AddEdge("A", "B", new[] { "1", "00" }, "0"); graph.AddEdge("A", "C", new[] { "4", "00" }, "0"); graph.AddEdge("B", "C", new[] { "1", "00" }, "0"); graph.AddEdge("C", "D", new[] { "1", "00" }, "0"); return(graph); }
/// <summary> /// Path creating and setting first location /// Lobby tells cleaner that there is a place to clean so based on that cleaner will get a destination to walk to and to clean /// </summary> /// <param name="destination"></param> /// <returns></returns> public List <Node> CreateGraph(LocationType destination) { Destination = destination; // Cleaner creates his path andreturns it Graph.Graph graph = new Graph.Graph(); Path = graph.CreateNodeGraph(Location.LocationType, Destination, PathFinding, CurrentEvent.EventType); // if visitor changes his mind, he's steps will be reset. Step 0 is his location where he stands on, we don't want him to walk to that place NextStep = 1; return(Path); }
public void FindPathTest() { Graph.Graph graph = CreateGraph(); Dijkstra dijkstra = new Dijkstra(graph); Path path = dijkstra.FindPath(_places[0], _places[3]); Assert.AreEqual(3, path.TotalLength.Hours); Assert.AreEqual("A", path.Steps[0].StartPlace.Id); Assert.AreEqual("B", path.Steps[1].StartPlace.Id); Assert.AreEqual("C", path.Steps[2].StartPlace.Id); Assert.AreEqual("D", path.Steps[2].EndPlace.Id); }
public Tensor[] Step(Graph.Graph f, Tensor[] x) { var res = new Tensor[x.Length]; var h = new Tensor(1, _bh.Col, true); for (var i = 0; i < x.Length; i++) { res[i] = Step(f, x[i], h); h = res[i]; } return(res); }
/// <summary> /// Finds the shortest path with the A* Algorithm /// </summary> /// <param name="g">the graph</param> /// <param name="start">the start node</param> /// <param name="end">the end node</param> /// <returns>A route with the shortest path</returns> public static Route FindShortestPath(Graph.Graph g, Node start, Node end) { List <Node> closedList = new List <Node>(); List <Node> openList = new List <Node>(); openList.Add(start); foreach (Node n in g.Nodes) { n.DistanceToStartNode = double.MaxValue; n.DistanceToEnd = double.MaxValue; } start.DistanceToStartNode = 0; start.DistanceToEnd = CalcHeuristicCost(start, end); while (openList.Count > 0) { Node current = GetNodeWithLowestDistanceToEnd(openList); if (current != null && current == end) { return(new Route(start, end)); } openList.Remove(current); closedList.Add(current); foreach (Node neighbor in current.GetNeighbours()) { if (closedList.Contains(neighbor)) { continue; } double suggestedDistanceFromStartToCurrent = current.DistanceToStartNode + current.GetWeightToNeighbour(neighbor); if (!openList.Contains(neighbor)) { openList.Add(neighbor); } else if (suggestedDistanceFromStartToCurrent >= neighbor.DistanceToStartNode) { continue; } neighbor.PreviousNode = current; neighbor.DistanceToStartNode = suggestedDistanceFromStartToCurrent; neighbor.DistanceToEnd = neighbor.DistanceToStartNode + CalcHeuristicCost(neighbor, end); } } return(null); }
public ComputationGraph(Graph.Graph graph, IPathFinder pathFinder, Vertex startVertex, Vertex endVertex) { _pathes = new List <List <DestroyableElement> >(); _units = new Dictionary <IGraphUnit, DestroyableElement>(); // Заполняем словарь элементами foreach (var vertex in graph.Vertex) { _units.Add(vertex, new DestroyableElement(vertex)); foreach (var edge in vertex.Edges) { if (!_units.ContainsKey(edge)) { _units.Add(edge, new DestroyableElement(edge)); } } } Pathes = pathFinder.FindAllPathes(graph, startVertex, endVertex); // На основе путей, составляем пути из DestroyableElements, так же добавляя // ребра между вершинами, потому что они тоже могут отказывать foreach (var path in Pathes) { var dPath = new List <DestroyableElement>(); for (int i = 0; i < path.Count - 1; i++) { var v1 = path[i]; var v2 = path[i + 1]; var edge = graph.GetEdge(v1, v2); // Ребро гарантированно существует var vUnit = _units[v1]; var vEdge = _units[edge]; vUnit.EncountsCount++; vEdge.EncountsCount++; dPath.Add(vUnit); dPath.Add(vEdge); } // Добавляем последнюю вершину var unit = _units[path[path.Count - 1]]; unit.EncountsCount++; dPath.Add(unit); _pathes.Add(dPath); } }
private static void AddEdge(Graph.Graph graph) { foreach (var ln in _data2) { List <String> data = ln.Split("|").ToList(); graph.AddEdge(data[1].Replace(" ", ""), data[2].Replace(" ", ""), data[3].Split(":"), data[5]); if (!data[4].Equals("0:00")) { graph.AddEdge(data[2].Replace(" ", ""), data[1].Replace(" ", ""), data[4].Split(":"), data[5]); } } }
/// <summary> /// Create a path. /// </summary> /// <param name="graph">The graph this path is through.</param> /// <param name="steps">The edges.</param> public Path(Graph.Graph graph, Edge[] steps) { this.graph = graph; this.steps = steps; }