Example #1
        /// <summary>  Parsing of the RGraph. This is the recursive method
        /// to perform a query. The method will recursively
        /// parse the RGraph thru connected nodes and visiting the
        /// RGraph using allowed adjacency relationship.
        /// </summary>
        /// <param name="traversed"> node already parsed
        /// </param>
        /// <param name="extension"> possible extension node (allowed neighbours)
        /// </param>
        /// <param name="forbiden">  node forbiden (set of node incompatible with the current solution)
        /// </param>
        private void parseRec(System.Collections.BitArray traversed, System.Collections.BitArray extension, System.Collections.BitArray forbidden)
            System.Collections.BitArray newTraversed = null;
            System.Collections.BitArray newExtension = null;
            System.Collections.BitArray newForbidden = null;
            System.Collections.BitArray potentialNode = null;

            // if there is no more extension possible we
            // have reached a potential new solution
            if (isEmpty(extension))
            // carry on with each possible extension
                // calculates the set of nodes that may still
                // be reached at this stage (not forbiden)
                potentialNode = ((System.Collections.BitArray)graphBitSet.Clone());
                //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Or' operation. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1083'"

                // checks if we must continue the search
                // according to the potential node set
                if (mustContinue(potentialNode))
                    // carry on research and update iteration count

                    // for each node in the set of possible extension (neighbours of 
                    // the current partial solution, include the node to the solution
                    // and perse recursively the RGraph with the new context.
                    for (int x = nextSetBit(extension, 0); x >= 0 && !stop; x = nextSetBit(extension, x + 1))
                        // evaluates the new set of forbidden nodes
                        // by including the nodes not compatible with the
                        // newly accepted node.
                        newForbidden = (System.Collections.BitArray)forbidden.Clone();
                        //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Or' operation. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1083'"

                        // if it is the first time we are here then
                        // traversed is empty and we initialize the set of
                        // possible extensions to the extension of the first
                        // accepted node in the solution.
                        if (isEmpty(traversed))
                            newExtension = (System.Collections.BitArray)(((RNode)graph[x]).extension.Clone());
                        // else we simply update the set of solution by
                        // including the neighbours of the newly accepted node
                            newExtension = (System.Collections.BitArray)extension.Clone();
                            //UPGRADE_NOTE: In .NET BitArrays must be of the same size to allow the 'System.Collections.BitArray.Or' operation. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1083'"

                        // extension my not contain forbidden nodes

                        // create the new set of traversed node
                        // (update current partial solution)
                        // and add x to the set of forbidden node
                        // (a node may only appear once in a solution)
                        newTraversed = (System.Collections.BitArray)traversed.Clone();
                        SupportClass.BitArraySupport.Set(newTraversed, x);
                        SupportClass.BitArraySupport.Set(forbidden, x);

                        // parse recursively the RGraph
                        parseRec(newTraversed, newExtension, newForbidden);
Example #2
    public static void TestNotIntervals()
      var empty = new int[0].ToList();
      var a = new[] {0, 3}.ToList();
      var b = new[] {2, 2}.ToList();
      var c = new[] {0, 2}.ToList();
      var d = new[] {1, 1}.ToList();
      var e = new[] {2, 1}.ToList();
      var f = new[] {0, 1}.ToList();
      var g = new[] {3, 1}.ToList();

      Assert.That(b.Not(a), Is.EqualTo(c));
      Assert.That(a.Not(b), Is.EqualTo(g));
      Assert.That(d.Not(c), Is.EqualTo(f));
      Assert.That(c.Not(d), Is.EqualTo(empty));
      Assert.That(e.Not(c), Is.EqualTo(c));
      Assert.That(c.Not(e), Is.EqualTo(e));

      Assert.That(a.Not(), Is.EqualTo(new[] {3}));