Exemplo n.º 1
0
 internal void removeFirst()
 {
     if (Head == Tail)
     {
         Head = Tail = null;
     }
     else
     {
         Head = Head.Next;
     }
 }
Exemplo n.º 2
0
        private IEnumerable <T> getDataAsEnumerable()
        {
            SNode traversal = Head;

            while (traversal != null)
            {
                yield return(traversal.Data);

                traversal = traversal.Next;
            }
        }
 private void AssignNeighbor(int nodeRow, int nodeCol, List <SNode> neighbors)
 {
     if (nodeRow != -1 && nodeCol != -1 && nodeRow < numRows && nodeCol < numCols)
     {
         SNode nodeToAdd = nodes[nodeRow, nodeCol];
         if (!nodeToAdd.bObstacle)
         {
             neighbors.Add(nodeToAdd);
         }
     }
 }
Exemplo n.º 4
0
    public SNode GetMetaData()
    {
        SNode x = new SNode();

        x.position    = transform.position;
        x.radius      = radius;
        x.distortion  = distortion;
        x.cubePortion = cubePortion;

        return(x);
    }
Exemplo n.º 5
0
 bool IsFullSN(SNode S)
 {
     if (MAXSIZE == S.rear)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Exemplo n.º 6
0
        public void RemoveNode(Node n)
        {
            if (!Contains(n))
            {
                return;
            }
            SNode node = GetSNode(n);

            nodes.Remove(node);
            Destroy(node.road);
        }
Exemplo n.º 7
0
 bool IsEmptySN(SNode S)
 {
     if (S.front == S.rear)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
        private static void UpdateUnitIds(SNode symbol, string symbolName, string partValue)
        {
            var unitIds = symbol.Childs
                          .Where(child => child.Name == "symbol")
                          .Select(unit => unit.Childs[0]);

            foreach (var unitId in unitIds)
            {
                unitId.Name = unitId.Name?.Replace(symbolName, partValue, StringComparison.Ordinal);
            }
        }
Exemplo n.º 9
0
 internal void insertFirst(SNode sNode)
 {
     if (Head == null && Tail == null)
     {
         Head = Tail = sNode;
     }
     else
     {
         sNode.Next = Head;
         Head       = sNode;
     }
 }
Exemplo n.º 10
0
        int CountNodes(SNode n)
        {
            int count = 0;

            while (n != null)
            {
                count++;
                n = n.Next;
            }

            return(count);
        }
Exemplo n.º 11
0
        /// <summary>
        /// 执行插入任务菜单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void OnAtvNode(object sender, Mi e)
        {
            SNode node = new SNode(_sketch)
            {
                Title  = "任务项",
                Shape  = "任务",
                Width  = 120,
                Height = 60
            };

            Insert(node);
        }
Exemplo n.º 12
0
 internal void insertLast(SNode sNode)
 {
     if (Head == null && Tail == null)
     {
         Head = Tail = sNode;
     }
     else
     {
         Tail.Next = sNode;
         Tail      = sNode;
     }
 }
Exemplo n.º 13
0
        public void Echo()
        {
            // Arrange
            var input = "((data \"quoted data\" \"\\\"quote\\\"\" 123 4.5) (data (!@# (4.5) \"(more\" \"data)\")))";

            // Act
            var sNode  = SNode.Parse(input);
            var output = sNode.ToString();

            // Assert
            Assert.Equal(input, output);
        }
        public void CreateNodeWithIntegerValue_StoresValue(int value)
        {
            // Arrange
            SNode node;
            int   expected = value;

            // Act
            node = new SNode(value);

            // Assert
            Assert.Equal(expected, node.Value);
        }
Exemplo n.º 15
0
            public Node Pop()
            {
                if (m_first == null)
                {
                    throw new Exception();
                }

                SNode first = m_first;

                m_first = m_first.N;
                return(first.Item);
            }
Exemplo n.º 16
0
    static void CollectChildren(SNode node, List <SNode> children)
    {
        foreach (SNode c in node.children)
        {
            if (IsSuitableNode(c))
            {
                children.Add(c);
            }

            CollectChildren(c, children);
        }
    }
    //static public List<SNode> asyncPath;

    private static List <SNode> CalculatePath(SNode sn)
    {
        List <SNode> list = new List <SNode>();

        while (sn != null)
        {
            list.Add(sn);
            sn = (SNode)sn.parent;
        }
        list.Reverse();
        return(list);
    }
Exemplo n.º 18
0
        public static List <int> ToList(SNode node)
        {
            var result = new List <int>();

            while (node != null)
            {
                result.Add(node.Value);
                node = node.Next;
            }

            return(result);
        }
Exemplo n.º 19
0
            public override Node Duplicate()
            {
                SNode sn = new SNode(Frame, Id);

                sn.Name = Name;
                sn.Edges.AddRange(Edges);
                sn.CustomData = new Dictionary <string, object>(this.CustomData);
                sn.Tags.AddRange(this.Tags);
                sn.Frame = this.Frame;

                return(sn);
            }
Exemplo n.º 20
0
    public static List <SNode> FindPath(SNode start, SNode goal)
    {
        openList = new SortedQueue <SNode>();
        openList.Push(start);
        start.initialCost   = 0.0f;
        start.estimatedCost = GetHeuristicEstimateCost(start, goal);
        start.nodeTotalCost = start.initialCost + start.estimatedCost;

        closedList = new HashSet <SNode>();
        SNode sNode = null;

        while (openList.Length != 0)
        {
            sNode = openList.First;
            if (sNode.position == goal.position)
            {
                return(CalculatePath(sNode));
            }

            List <SNode> neighbors = new List <SNode>();
            GridHandler.S.GetNeighbors(sNode, neighbors);

            for (int i = 0; i < neighbors.Count; i++)
            {
                SNode neighborNode = neighbors[i];
                if (!closedList.Contains(neighborNode))
                {
                    neighborNode.estimatedCost = GetHeuristicEstimateCost(neighborNode, goal);
                    neighborNode.initialCost   = sNode.initialCost + 1;
                    neighborNode.nodeTotalCost = neighborNode.estimatedCost + neighborNode.initialCost;

                    neighborNode.parent = sNode;
                    if (!openList.Contains(neighborNode))
                    {
                        openList.Push(neighborNode);
                    }
                }
            }

            closedList.Add(sNode);
            openList.Remove(sNode);
        }

        //If finished looping and cannot find the goal then return null
        if (sNode.position != goal.position)
        {
            Debug.LogError("Goal Not Found");
            return(null);
        }

        //Calculate the path based on the final node
        return(CalculatePath(sNode));
    }
Exemplo n.º 21
0
        public void TestMethod15()
        {
            SNode head = null;

            head = SinglyLinkedListOps.AddTail(head, 1);
            head = SinglyLinkedListOps.AddTail(head, 2);
            head = SinglyLinkedListOps.AddTail(head, 3);
            head = SinglyLinkedListOps.DeleteAll(head, 2);
            ValidateList(head, new List <int> {
                1, 3
            });
        }
Exemplo n.º 22
0
        public void Serialize_Non_Primitive_Node(string expectedOutput, string key, params string[] childs)
        {
            // Arrange
            var childNodes = childs.Select(child => new SNode(child)).ToArray();
            var node       = new SNode(key, childNodes);

            // Act
            var output = node.ToString();

            // Assert
            output.Should().Be(expectedOutput);
        }
Exemplo n.º 23
0
        /// <summary>
        /// 执行插入开始菜单
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void OnStartNode(object sender, Mi e)
        {
            SNode node = new SNode(_sketch)
            {
                Title  = "开始",
                Shape  = "开始",
                Width  = 80,
                Height = 60
            };

            Insert(node);
        }
Exemplo n.º 24
0
        public void Parse_Non_Primitive_Node(string input, string key, params string[] childs)
        {
            // Arrange
            var childNodes   = childs.Select(child => new SNode(child)).ToArray();
            var expectedNode = new SNode(key, childNodes);

            // Act
            var node = SNode.Parse(input);

            // Assert
            node.Should().BeEquivalentTo(expectedNode);
        }
Exemplo n.º 25
0
    public void GetNeighbors(SNode node, List <SNode> neighbors)
    {
        Vector3 neighborPos   = node.position;
        int     neighborIndex = GetGridIndex(neighborPos);

        int row = GetRow(neighborIndex);
        int col = GetColumn(neighborIndex);

        //Bottom
        int nodeRow = row - 1;
        int nodeCol = col;

        AssignNeighbor(nodeRow, nodeCol, neighbors);

        //Top
        nodeRow = row + 1;
        nodeCol = col;
        AssignNeighbor(nodeRow, nodeCol, neighbors);

        //Right
        nodeRow = row;
        nodeCol = col + 1;
        AssignNeighbor(nodeRow, nodeCol, neighbors);

        //Left
        nodeRow = row;
        nodeCol = col - 1;
        AssignNeighbor(nodeRow, nodeCol, neighbors);

        if (useDiagonal)
        {
            //BottomLeft
            nodeRow = row - 1;
            nodeCol = col - 1;
            AssignNeighbor(nodeRow, nodeCol, neighbors);

            //TopLeft
            nodeRow = row + 1;
            nodeCol = col - 1;
            AssignNeighbor(nodeRow, nodeCol, neighbors);

            //TopRight
            nodeRow = row + 1;
            nodeCol = col + 1;
            AssignNeighbor(nodeRow, nodeCol, neighbors);

            //BottomRight
            nodeRow = row - 1;
            nodeCol = col + 1;
            AssignNeighbor(nodeRow, nodeCol, neighbors);
        }
    }
Exemplo n.º 26
0
        public void TestMethod6()
        {
            SNode head = null;

            head = SinglyLinkedListOps.AddTail(head, 1);
            head = SinglyLinkedListOps.AddTail(head, 2);
            head = SinglyLinkedListOps.AddTail(head, 3);

            Assert.AreEqual(1, head.data);
            Assert.AreEqual(2, head.next.data);
            Assert.AreEqual(3, head.next.next.data);
            Assert.IsNull(head.next.next.next);
        }
Exemplo n.º 27
0
        public void TestMethod11()
        {
            SNode head = null;

            head = SinglyLinkedListOps.InsertAt(head, 1, 0);
            head = SinglyLinkedListOps.InsertAt(head, 2, 0);
            head = SinglyLinkedListOps.InsertAt(head, 3, 100);

            Assert.AreEqual(2, head.data);
            Assert.AreEqual(1, head.next.data);
            Assert.AreEqual(3, head.next.next.data);
            Assert.IsNull(head.next.next.next);
        }
Exemplo n.º 28
0
    public SNode DeepCopy()
    {
        SNode copy = (SNode)MemberwiseClone();

        copy.Possibles = new OrderedSet <int>();

        foreach (int value in this.Possibles)
        {
            copy.Possibles.Add(value);
        }

        return(copy);
    }
Exemplo n.º 29
0
            void _DetachFromDeleted(SNode Node_)
            {
                _Detach(Node_);

                if (Node_.Prev == null)
                {
                    _DeletedHead = Node_.Next;
                }
                if (Node_.Next == null)
                {
                    _DeletedTail = Node_.Prev;
                }
            }
Exemplo n.º 30
0
        internal void clear()
        {
            SNode traversal = Head;

            while (traversal != null)
            {
                SNode temp = traversal.Next;
                traversal.Next = null;
                traversal      = temp;
            }

            Head = Tail = null;
        }
Exemplo n.º 31
0
    public bool Match(SNode node)
    {
        if (!parts_of_speech.Contains(node.word.part_of_speech))
            return false;

        for (int i = 0; i < children.Count; ++i)
        {
            bool child_found = false;

            for (int j = 0; j < node.children.Count; ++j)
                if (node.edge_types[j].Equals(edge_type[i], StringComparison.CurrentCultureIgnoreCase))
                {
                    if (children[i].Match(node.children[j]))
                    {
                        child_found = true;
                        break;
                    }
                }

            if (!child_found)
                return false;
        }

        return true;
    }
Exemplo n.º 32
0
    public Sentence(XmlNode n_sent)
    {
        text = n_sent.SelectSingleNode("text").InnerText;

        // токены
        tokens = new List<SToken>();
        int token_index = 0;
        foreach (XmlNode n_token in n_sent.SelectNodes("tokens/token"))
        {
            SToken t = new SToken(token_index, n_token);
            tokens.Add(t);
            token_index++;
        }

        // дерево зависимостей
        List<int> root_index = new List<int>();
        Dictionary<int, int> child2parent = new Dictionary<int, int>();
        Dictionary<KeyValuePair<int, int>, string> edge_type = new Dictionary<KeyValuePair<int, int>, string>();
        Dictionary<int, List<int>> parent2child = new Dictionary<int, List<int>>();

        foreach (XmlNode n_token in n_sent.SelectNodes("syntax_tree/node"))
        {
            int child_index = int.Parse(n_token["token"].InnerText);

            if (n_token.Attributes["is_root"] != null && n_token.Attributes["is_root"].Value == "true")
                root_index.Add(child_index);
            else
            {
                int parent_index = int.Parse(n_token["parent"].InnerText);
                child2parent.Add(child_index, parent_index);

                edge_type.Add(new KeyValuePair<int, int>(child_index, parent_index), n_token["link_type"].InnerText);

                List<int> child_idx;
                if (!parent2child.TryGetValue(parent_index, out child_idx))
                {
                    child_idx = new List<int>();
                    parent2child.Add(parent_index, child_idx);
                }

                child_idx.Add(child_index);
            }
        }

        nodes = new List<SNode>();
        for (int inode = 0; inode < tokens.Count; ++inode)
        {
            SNode n = new SNode();
            n.index = inode;
            n.word = tokens[inode];
            nodes.Add(n);
        }

        // проставим родителей и детей в каждом узле
        for (int inode = 0; inode < nodes.Count; ++inode)
        {
            SNode node = nodes[inode];

            if (!root_index.Contains(node.index))
            {
                SNode parent_node = nodes[child2parent[node.index]];
                node.parent = parent_node;

                parent_node.children.Add(node);
                parent_node.edge_types.Add(edge_type[new KeyValuePair<int, int>(node.index, parent_node.index)]);
            }
            else
            {
                root = node;
            }
        }
    }
Exemplo n.º 33
0
 /// <summary>
 /// Extract SNode.Argument[] into system object[] data.
 /// </summary>
 /// <param name="args">SNode arguments.</param>
 /// <returns></returns>
 public static object[] extract(SNode.Argument[] args)
 {
     object[] ret = new object[args.Length];
     for(int i = 0; i < args.Length; ++i)
     {
         if(args[i].data is SNode.Argument[]) {
             ret[i] = extract((SNode.Argument[])args[i].data);
             continue;
         }
         ret[i] = args[i].data;
     #if DEBUG
         Log.Trace("Value.extract: SNode.Argument - '{0}'", ret[i]);
     #endif
     }
     return ret;
 }