public override void Populate(IGraph <TItem, TEdge> graph) { var lastNode1 = default(TItem); var lastNode2 = default(TItem);; var lastNode3 = default(TItem);; for (int i = 0; i < Count; i++) { if (i > 0) { lastNode1 = Nodes[1]; lastNode2 = Nodes[5]; lastNode3 = Nodes[8]; } Populate(graph, Start + 1); if (i > 0) { var edge = CreateEdge(lastNode1, Nodes[1]); graph.Add(edge); if (SeperateLattice) { edge = CreateEdge(lastNode2, Nodes[5]); graph.Add(edge); } if (AddDensity) { edge = CreateEdge(Nodes[2], lastNode3); graph.Add(edge); } } } }
public void TestSaveGraphWithUnknownNode() { graph = new Graph(); var A = new TestSubNode() { Label = "A" }; var B = new Node() { Label = "B" }; var C = new Node() { Label = "C" }; var D = new TestSubNode() { Label = "D" }; var E = new TesteSubNode2() { Label = "E" }; graph.Add(A); graph.Add(B); graph.Add(C); graph.Add(D); graph.Add(E); graph.ConnectNodeToWith(A, B, new Edge(new AttributePair <Double> { Name = "Weight", Attribute = 8 })); graph.ConnectNodeToWith(A, D, new TestSubEdge(9)); graph.ConnectNodeToWith(A, E, new Edge(new AttributePair <Double> { Name = "Weight", Attribute = 4 })); graph.ConnectNodeToWith(B, C, new Edge(new AttributePair <Double> { Name = "Weight", Attribute = 1 })); graph.ConnectNodeToWith(C, B, new Edge(new AttributePair <Double> { Name = "Weight", Attribute = 2 })); graph.ConnectNodeToWith(C, D, new TestSubEdge(3)); graph.ConnectNodeToWith(D, C, new Edge(new AttributePair <Double> { Name = "Weight", Attribute = 2 })); graph.ConnectNodeToWith(D, E, new Edge(new AttributePair <Double> { Name = "Weight", Attribute = 7 })); graph.ConnectNodeToWith(E, C, new Edge(new AttributePair <Double> { Name = "Weight", Attribute = 1 })); writer.Save(graphExoticNodePath, graph); }
public override void Populate(IGraph <TItem, TEdge> graph, int start) { var item = CreateItem <int>((start++)); graph.Add(item); Nodes[1] = item; item = CreateItem <int>((start++)); graph.Add(item); Nodes[2] = item; Edges[1] = CreateEdge(Nodes[1], Nodes[2]); graph.Add(Edges[1]); }
public void AdjacentTest() { IGraph <int> graph = GraphMap.New <int>(); for (int i = 1; i <= 5; i++) { graph.Add(i); } graph.Add(1, 5); graph.Add(2, 5); graph.Add(3, 5); graph.Add(4, 5); Assert.IsTrue(graph.Adjacent(1, 5)); }
public void TestWriter1000NodeGraph() { graph = new Graph(); List <INode> nodes = new List <INode>(); for (int i = 0; i != 1000; ++i) { var node = new TesteSubNode2(); nodes.Add(node); graph.Add(node); } Assert.AreEqual(nodes.Count, graph.NodeCount); Assert.AreEqual(1000, graph.NodeCount); Random random = new Random(); for (int i = 0; i != 1000; ++i) { var index1 = random.Next(0, 1000); var index2 = random.Next(0, 1000); while (index2 == index1) { index2 = random.Next(0, 1000); } graph.ConnectNodeToWith(nodes[index1], nodes[index2], new Edge(new AttributePair <Double> { Name = "Weight", Attribute = random.Next(1, 600) })); } Assert.AreEqual(graph.AllEdges.Count, 1000); writer.Save("Large Graph.xml", graph); }
public void FillGraph(IGraph <TItem, TEdge> graph, BasicGraphTestDataFactory <TItem, TEdge> data) { foreach (var edge in data.Edges) { graph.Add(edge); } }
public NNValue Activate(NNValue input, IGraph g) { NNValue sum = g.Add(g.Mul(_w, input), _b); NNValue returnObj = g.Nonlin(_f, sum); return(returnObj); }
public virtual void AddSamplesToGraph(IGraph <TItem, TEdge> graph) { foreach (var item in Nodes) { if (item != null) { graph.Add(item); } } foreach (var item in Edges) { if (item != null) { graph.Add(item); } } }
public static void AddRange <TItem, TEdge>(this IGraph <TItem, TEdge> graph, IEnumerable <TItem> items) where TEdge : IEdge <TItem> { foreach (var item in items) { graph.Add(item); } }
private GraphNode <GraphNodeAnnotationData> AddVertex(PropGraphNodeDescriptor analysisNode) { long index; GraphNode <GraphNodeAnnotationData> node = null; if (!vIndex.TryGetValue(analysisNode, out index)) { var data = new GraphNodeAnnotationData(analysisNode); index = (long)vIndex.Count; vIndex[analysisNode] = index; graph.Add(index, data); } node = graph.GetNode(index); return(node); }
/// <summary> /// Adds a node to the graph. /// </summary> /// <param name="graph">The graph.</param> /// <param name="nodeData">The node data.</param> /// <returns>The added node.</returns> public static Node <NodeData, EdgeData> AddNode(this IGraph <NodeData, EdgeData> graph, NodeData nodeData) { var node = new Node <NodeData, EdgeData>(nodeData); graph.Add(node); return(node); }
/// <summary> /// Adds an edge to the graph. /// </summary> /// <param name="graph">The graph.</param> /// <param name="firstNode">The first node.</param> /// <param name="secondNode">The second node.</param> /// <param name="edgeData">The data attached to the edge.</param> /// <returns>The added edge.</returns> public static Edge <NodeData, EdgeData> AddEdge(this IGraph <NodeData, EdgeData> graph, Node <NodeData, EdgeData> firstNode, Node <NodeData, EdgeData> secondNode, EdgeData edgeData) { var edge = new Edge <NodeData, EdgeData>(firstNode, secondNode, edgeData); graph.Add(edge); return(edge); }
public void RemoveTest() { IGraph <int> graph = GraphMap.New <int>(); for (int i = 1; i <= 5; i++) { graph.Add(i); } graph.Add(1, 5); graph.Add(2, 5); graph.Add(3, 5); graph.Add(4, 5); graph.Remove(3); ListArray <(int, int)> RemainingEdges = new(); graph.Edges(edge => RemainingEdges.Add((edge.Item1, edge.Item2))); Assert.IsTrue(EquateSet <(int, int)>(new[] { (1, 5), (2, 5), (4, 5) }, RemainingEdges.ToArray()));
internal static IVertex AddNamedNode(this IGraph graph, string name) { var vertex = new Vertex { Name = name, }; graph.Add(vertex); return(vertex); }
public NNValue Activate(NNValue input, IGraph g) { NNValue concat = g.ConcatVectors(input, _context); NNValue sum = g.Mul(_w, concat); sum = g.Add(sum, _b); NNValue output = g.Nonlin(_f, sum); //rollover activations for next iteration _context = output; return(output); }
private void ConstructGraph() { var u1 = _sut.Add(new Tag { Name = "U1" }); var u2 = _sut.Add(new Tag { Name = "U2" }); var s1 = _sut.Add(new Tag { Name = "S1" }); var a1 = _sut.Add(new Tag { Name = "A1" }); var a2 = _sut.Add(new Tag { Name = "A2" }); var b1 = _sut.Add(new Tag { Name = "B1" }); _sut.SaveChanges(); s1.AddParent(u1); a1.AddParent(s1); b1.AddParent(a2); a2.AddParent(s1); b1.AddParent(a1); s1.AddParent(u2); _sut.CommitAllChanges(); }
private void ConstructGraph() { _sut.Add(new Tag { Name = "0" }); _sut.Add(new Tag { Name = "1" }); _sut.Add(new Tag { Name = "2" }); _sut.Add(new Tag { Name = "3" }); _sut.Add(new Tag { Name = "4" }); _sut.Add(new Tag { Name = "5" }); _sut.SaveChanges(); _sut["2"].AddParent(_sut["3"]); _sut["0"].AddParent(_sut["1"]); _sut["3"].AddParent(_sut["4"]); _sut["4"].AddParent(_sut["5"]); _sut["1"].AddParent(_sut["2"]); _sut.CommitAllChanges(); }
private void CreateNonexistentTags(IEnumerable <string> tagNames) { var existingNames = _graph.Vertices.Select(vertex => vertex.Entity.Name); foreach (var tagName in tagNames.Except(existingNames)) { _graph.Add(new Tag { Name = tagName }); } _graph.SaveChanges(); }
public void Initialize() { src = new Node() { Label = "A" }; graph = new Graph(); graph.Add(src); nodes = new Node[5]; nodes[0] = src; for (int i = 1; i != nodes.Length; ++i) { int val = 'A'; nodes[i] = new Node { Label = Convert.ToString(Convert.ToChar(val + i)) }; graph.Add(nodes[i]); } route1 = new Route(src, "Weight"); route2 = new Route(src, "Weight"); }
public virtual IThing SetThingByData(IGraph <IThing, ILink> graph, IThing thing, object data) { var itemToChange = graph.ThingToDisplay(thing); if (thing != null && itemToChange == thing && SchemaFacade.DescriptionableThing(thing)) { itemToChange = ThingFactory.CreateItem(data); graph.Add(new Link(thing, itemToChange, CommonSchema.DescriptionMarker)); } else { graph.DoChangeData(itemToChange, data); } return(itemToChange); }
public override void Populate(IGraph <TItem, TEdge> graph, int start) { base.Populate(graph, start); var edge = default(TEdge);; #region Binarytree Edges edge = CreateEdge(Nodes[1], Nodes[2]); graph.Add(edge); Edges[1] = edge; edge = CreateEdge(Nodes[4], Nodes[3]); graph.Add(edge); Edges[2] = edge; edge = CreateEdge(Nodes[1], Edges[2]); graph.Add(edge); Edges[3] = edge; edge = CreateEdge(Nodes[5], Nodes[8]); graph.Add(edge); Edges[4] = edge; edge = CreateEdge(Nodes[5], Nodes[6]); graph.Add(edge); Edges[5] = edge; edge = CreateEdge(Nodes[5], Nodes[7]); graph.Add(edge); Edges[6] = edge; edge = CreateEdge(Nodes[8], Nodes[9]); graph.Add(edge); Edges[7] = edge; if (!SeperateLattice) { edge = CreateEdge(Edges[2], Edges[4]); graph.Add(edge); Edges[8] = edge; } #endregion }
public virtual void Populate(IGraph <TItem, TEdge> graph, int start) { var item = CreateItem <int> ((start++)); graph.Add(item); Nodes[1] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[2] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[3] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[4] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[5] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[6] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[7] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[8] = item; item = CreateItem <int> ((start++)); graph.Add(item); Nodes[9] = item; this.Start = start; }
public void GivenSelfReferencingVertex_ThenThrowsCycleException() { var tag = _sut.Add(new Tag { Name = "Sample tag" }); _sut.SaveChanges(); Action act = () => tag.AddParent(tag); act.Should().Throw <CycleException>(); }
public NNValue Activate(NNValue input, IGraph g) { //input gate NNValue sum0 = g.Mul(_wix, input); NNValue sum1 = g.Mul(_wih, _hiddenContext); NNValue inputGate = g.Nonlin(_inputGateActivation, g.Add(g.Add(sum0, sum1), _inputBias)); //forget gate NNValue sum2 = g.Mul(_wfx, input); NNValue sum3 = g.Mul(_wfh, _hiddenContext); NNValue forgetGate = g.Nonlin(_forgetGateActivation, g.Add(g.Add(sum2, sum3), _forgetBias)); //output gate NNValue sum4 = g.Mul(_wox, input); NNValue sum5 = g.Mul(_woh, _hiddenContext); NNValue outputGate = g.Nonlin(_outputGateActivation, g.Add(g.Add(sum4, sum5), _outputBias)); //write operation on cells NNValue sum6 = g.Mul(_wcx, input); NNValue sum7 = g.Mul(_wch, _hiddenContext); NNValue cellInput = g.Nonlin(_cellInputActivation, g.Add(g.Add(sum6, sum7), _cellWriteBias)); //compute new cell activation NNValue retainCell = g.Elmul(forgetGate, _cellContext); NNValue writeCell = g.Elmul(inputGate, cellInput); NNValue cellAct = g.Add(retainCell, writeCell); //compute hidden state as gated, saturated cell activations NNValue output = g.Elmul(outputGate, g.Nonlin(_cellOutputActivation, cellAct)); //rollover activations for next iteration _hiddenContext = output; _cellContext = cellAct; return(output); }
/// <summary> /// Restores from a **XElement** node to /// a <see cref="IGraph"/>. /// </summary> /// <param name="root"> /// The root node where the Xml representation of **graph** is stored at. /// </param> /// <remarks> /// > [!Note] /// > This method utilises <see cref="LoadNode(XElement)"/>, /// > <see cref="LoadEdge(XElement)"/>, <see cref="SetIdsStartFrom(XElement)"/> /// > and <see cref="CreateXElementIdGenerator"/> to restore all the details /// > of a **graph**. /// </remarks> protected virtual IGraph Dump(XElement root) { XElement dependencies = root.Element("Dependencies"); foreach (var dependency in dependencies.Elements()) { String assemPath = dependency.Attribute("Name").Value; foreach (var type in dependency.Elements("Type")) { DependencyMap[type.Value] = Assembly.LoadFrom(assemPath); } } XElement xgraph = root.Element("Graph"); var graphTypeName = xgraph.Attribute("Type").Value; Type graphType = DependencyMap[graphTypeName].GetType(graphTypeName); IGraph graph = Activator.CreateInstance(graphType) as IGraph; IEnumerable <XElement> xnodes = xgraph.Element("Nodes").Elements(); foreach (XElement xnode in xnodes) { graph.Add(LoadNode(xnode)); } IEnumerable <XElement> xedges = xgraph.Element("Edges").Elements(); foreach (XElement xedge in xedges) { var tuple = LoadEdge(xedge); var from = graph.AllNodes[tuple.From]; var to = graph.AllNodes[tuple.To]; var edge = tuple.Through; graph.ConnectNodeToWith(from, to, edge); } SetIdsStartFrom(root); return(graph); }
public override void Populate(IGraph <TItem, TEdge> graph, int start) { var node = default(TItem); var edge = default(TEdge); node = CreateItem <string>("Tags"); graph.Add(node); Nodes[1] = node; node = CreateItem <string>("Word"); graph.Add(node); Nodes[2] = node; edge = CreateEdge(Nodes[1], Nodes[2]); graph.Add(edge); Edges[1] = edge; node = CreateItem <string>("Game"); graph.Add(node); Nodes[3] = node; edge = CreateEdge(Nodes[2], Nodes[3]); graph.Add(edge); Edges[2] = edge; node = CreateItem <string>("Something"); graph.Add(node); Nodes[4] = node; edge = CreateEdge(Edges[2], Nodes[4]); graph.Add(edge); Edges[3] = edge; edge = CreateEdge(Nodes[1], Edges[2]); graph.Add(edge); Edges[4] = edge; }
public void NeighborsTest() { IGraph <int> graph = GraphMap.New <int>(); for (int i = 1; i <= 5; i++) { graph.Add(i); } graph.Add(1, 5); graph.Add(2, 5); graph.Add(3, 5); graph.Add(4, 5); graph.Add(5, 2); graph.Add(5, 3); int sum = 0; graph.Neighbors(5, (x) => sum += x); Assert.IsTrue(sum is 5); }
public void RefreshCompression(IGraph <IThing, ILink> graph, IThing thing, bool act) { var streamThing = thing as IStreamThing; if (streamThing == null || streamThing.Compression != CompressionType.None) { return; } var comp = CompressionType.None; if (!_compressions.TryGetValue(streamThing.StreamType, out comp)) { var info = ContentInfoPool.FirstOrDefault(i => i.ContentType == streamThing.StreamType); if (info != null) { comp = info.Compression; _compressions[info.ContentType] = info.Compression; WriteLog("Comp for {0}: {1} | {2}", info.Description, comp, streamThing.StreamType.ToString("X")); } } if (comp != CompressionType.None) { WriteLog("{0} -> {1} |{2}:{3}", streamThing.Compression, comp, streamThing.Id.ToString("X"), streamThing.StreamType.ToString("X")); streamThing.DeCompress(); var oldSize = streamThing.Data.Length; if (act) { streamThing.Compression = comp; if (comp != CompressionType.neverCompress) { streamThing.Compress(); streamThing.Flush(); streamThing.ClearRealSubject(); WriteLog("\t{0} -> {1}", oldSize, streamThing.Data.Length); } graph.Add(streamThing); } } }
public static void Main() { Console.WriteLine("You are runnning the GraphSearch example."); Console.WriteLine("======================================================"); Console.WriteLine(); #region Simple Example { Console.WriteLine(" Graph Searching----------------------"); Console.WriteLine(); Console.WriteLine(" Graph:"); Console.WriteLine(); Console.WriteLine(" [0]-----(1)---->[1] "); Console.WriteLine(" | | "); Console.WriteLine(" | | "); Console.WriteLine(" (99) (2) "); Console.WriteLine(" | | "); Console.WriteLine(" | | "); Console.WriteLine(" v v "); Console.WriteLine(" [3]<----(5)-----[2] "); Console.WriteLine(); Console.WriteLine(" [nodes in brackets]"); Console.WriteLine(" (edge costs in parenthases)"); Console.WriteLine(); // make a graph IGraph <int> graph = GraphSetOmnitree.New <int>(); // add nodes graph.Add(0); graph.Add(1); graph.Add(2); graph.Add(3); // add edges graph.Add(0, 1); graph.Add(1, 2); graph.Add(2, 3); graph.Add(0, 3);
private void ConstructGraph() { foreach (var name in new[] { "0", "1", "2", "3", "4", "5", "6", "7" }) { _sut.Add(new Tag { Name = name }); } _sut.SaveChanges(); _sut["0"].AddParent(_sut["1"]); _sut["1"].AddParent(_sut["2"]); _sut["1"].AddParent(_sut["3"]); _sut["3"].AddParent(_sut["4"]); _sut["5"].AddParent(_sut["0"]); _sut["6"].AddParent(_sut["5"]); _sut["7"].AddParent(_sut["5"]); _sut.SaveChanges(); _sut["0"].DeleteParent(_sut["1"]); _sut.CommitAllChanges(); }