Esempio n. 1
0
        private HexagonRemoveModel RemoveIterative(HexagonRemoveModel returnModel, long levelUpperBound)
        {
            int address = 10; // Entry point for each each "call"
            HexagonRemoveModel tempModel = returnModel;
            Stack stack = new Stack();

            stack.Push(30); //initial return address
            stack.Push(tempModel);
            while (stack.Count > 0)
            {
                switch (address)
                {
                    case 10:
                    {
                        // Do something
                        returnModel = (HexagonRemoveModel)stack.Pop();

                        int id = returnModel.ID;
                        ArrayList[] btg = returnModel.Btg;
                        int[] next = returnModel.Next;
                        int[] prev = returnModel.Prev;
                        int[] level = returnModel.Level;
                        int[] weight = returnModel.Weight;

                        //check if the node has already been removed
                        if (prev[id] == -1)
                        {
                            //go to next address
                            address = (int)stack.Pop();
                            stack.Push(returnModel);
                            break;
                        }
                        if (next[prev[id]] != id)
                        {
                            //go to next address
                            address = (int)stack.Pop();
                            stack.Push(returnModel);
                            break;
                        }
                        else
                        {
                            //remove the node from next/prev relation
                            next[prev[id]] = next[id];
                            if (next[id] != -1)
                            {
                                prev[next[id]] = prev[id];
                            }

                            //remove tuples in node
                            btg[id] = null;

                        }

                        //remove followers
                        // follow the edge for preference i (only if not already on last level)
                        //if (id + weight[0] <= level.GetUpperBound(0) && level[id + weight[0]] == level[id] + 1)
                        //TODO: Profiling separate long variable instead of GetUpperBound(0) --> No significant effect (14% from the function instead of 15%)
                        if (id + weight[0] <= levelUpperBound && level[id + weight[0]] == level[id] + 1)
                        {
                            //Push current object to stack
                            returnModel.Loopindex = 1;  //important: raise loop Index!! new position in position loop!!
                            returnModel.Next = next;
                            returnModel.Prev = prev;
                            returnModel.Btg = btg;
                            stack.Push(returnModel);
                            stack.Push(20);

                            //Push new object to stack
                            HexagonRemoveModel nMinus1 = new HexagonRemoveModel(id + weight[0], 0, btg, next, prev, level, weight, 0);
                            stack.Push(nMinus1);
                            address = 10; // Make another "call"
                            break;
                        }

                        //Contains no childs --> goto next address
                        //The base case
                        address = (int)stack.Pop();
                        returnModel.Next = next;
                        returnModel.Prev = prev;
                        returnModel.Btg = btg;
                        stack.Push(returnModel);

                        break;
                    }
                    case 20:
                    {
                        // Compute and return
                        tempModel = (HexagonRemoveModel)stack.Pop();
                        returnModel = (HexagonRemoveModel)stack.Pop();

                        //Read
                        int id = returnModel.ID;
                        int index = returnModel.Index;
                        ArrayList[] btg = returnModel.Btg;
                        int[] next = returnModel.Next;
                        int[] prev = returnModel.Prev;
                        int[] level = returnModel.Level;
                        int[] weight = returnModel.Weight;
                        int iLoopIndex = returnModel.Loopindex;

                        bool isEndOfLoop = true;

                        //remove followers
                        for (int i = iLoopIndex; i <= index; i++)
                        {
                            // follow the edge for preference i (only if not already on last level)
                            if (id + weight[i] <= level.GetUpperBound(0) && level[id + weight[i]] == level[id] + 1)
                            {
                                //Push current object to stack
                                //important: raise loop Index!! new position in position loop!! --> The next time i will be initialized by this index
                                returnModel.Loopindex = i + 1;
                                stack.Push(returnModel);
                                stack.Push(20);

                                //Push new object to stack
                                HexagonRemoveModel deeperNode = new HexagonRemoveModel(id + weight[i], i, btg, next, prev, level, weight, 0);
                                stack.Push(deeperNode);
                                address = 10; // Make another "call"
                                isEndOfLoop = false;
                                break;
                            }
                        }

                        if (isEndOfLoop)
                        {
                            //Read next address and push current object to stack
                            address = (int)stack.Pop();
                            stack.Push(returnModel);
                        }

                        break;
                    }
                    case 30:
                    {
                        // The final return value
                        tempModel = (HexagonRemoveModel)stack.Pop();
                        break;
                    }
                }

            }
            return tempModel;
        }
Esempio n. 2
0
        //Find BestMatchesOnly
        private void FindBmo(int amountPreferences, ref ArrayList[] btg, ref int[] next, ref int[] prev, ref int[] level, ref int[] weight)
        {
            int last = 0;
            long levelUpperBound = level.GetUpperBound(0);

            // special case: top node is not empty
            if (btg[0] != null)
            {
                //Top node contains a tuple --> This is the perfect tuple. Set next to -1,
                next[0] = -1;

            }
            else
            {
                //follow the breadth-first walk
                int cur = 1;
                //while (cur != -1)
                while (cur != -1 && next[cur] != -1) //<= btg.GetUpperBound(0)
                {
                    if (btg[cur] != null)
                    {
                        // non-empty node belonging to BMO set
                        int nextCur = next[cur];
                        last = cur;
                        // remove all nodes dominated by current
                        for (int i = 0; i < amountPreferences; i++)
                        {
                            // check if there is an edge for Pi
                            if (cur + weight[i] <= level.GetUpperBound(0))
                            {
                                if (level[cur + weight[i]] == level[cur] + 1)
                                {
                                    HexagonRemoveModel modelIn = new HexagonRemoveModel(cur + weight[i], i, btg, next, prev, level, weight, 0);
                                    //removeRecursive(cur + weight[i], i, ref btg, ref next, ref prev, ref level, ref weight, 0);

                                    HexagonRemoveModel modelOut = RemoveIterative(modelIn, levelUpperBound);
                                    btg = modelOut.Btg;
                                    next = modelOut.Next;
                                    prev = modelOut.Prev;

                                }
                            }

                        }
                        cur = nextCur;

                    }
                    else
                    {
                        // node is empty: remove from next/prev
                        int nextCur = next[cur];

                        next[last] = next[cur];
                        prev[next[cur]] = last;
                        next[cur] = -1; //gibt es nicht mehr dieses node
                        prev[cur] = -1;

                        cur = nextCur; //Damit Breadt-First Walk
                    }

                }

            }
        }