예제 #1
0
 private void init()
 {
     this.cdif  = this.compact_diff(this.left, this.right);
     this._Same = true;
     if ((this.cdif[2] == 0) && (this.cdif[3] == 0))
     {
         this._Same = false;
         this.cdif.RemoveAt(0);
         this.cdif.RemoveAt(0);
     }
     this._End = (1 + this.cdif.Count) / 2;
 }
예제 #2
0
        void init()
        {
            cdif  = compact_diff(left, right);
            _Same = true;
            if (0 == (int)cdif[2] && 0 == (int)cdif[3])
            {
                _Same = false;
                cdif.RemoveAt(0);
                cdif.RemoveAt(0);
            }

            _End = (1 + cdif.Count) / 2;
        }
예제 #3
0
        void init()
        {
            compactDiff = compact_diff(left, right);
            same        = true;
            if (0 == compactDiff[2] && 0 == compactDiff[3])
            {
                same = false;
                compactDiff.RemoveAt(0);
                compactDiff.RemoveAt(0);
            }

            end = (1 + compactDiff.Count) / 2;
        }
예제 #4
0
        /*void prepare(IList list) {
         *  prepared = _withPositionsOfInInterval(list, 0, list.Count-1);
         *  preparedlist = list;
         * }*/

        void LongestCommonSubsequenceIndex(IList a, IList b, out IntList am, out IntList bm)
        {
            IntList match = LongestCommonSubsequence(a, b);

            am = new IntList();
            for (int i = 0; i < match.Count; i++)
            {
                if (match[i] != -1)
                {
                    am.Add(i);
                }
            }
            bm = new IntList();
            for (int vi = 0; vi < am.Count; vi++)
            {
                bm.Add(match[am[vi]]);
            }
        }
예제 #5
0
        private void LCSidx(IList a, IList b, out IntList am, out IntList bm)
        {
            IntList list = this._longestCommonSubsequence(a, b);

            am = new IntList();
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] != -1)
                {
                    am.Add(i);
                }
            }
            bm = new IntList();
            for (int j = 0; j < am.Count; j++)
            {
                bm.Add(list[am[j]]);
            }
        }
예제 #6
0
        /*
         # Find the place at which aValue would normally be inserted into the
         # array. If that place is already occupied by aValue, do nothing, and
         # return undef. If the place does not exist (i.e., it is off the end of
         # the array), add it to the end, otherwise replace the element at that
         # point with aValue.  It is assumed that the array's values are numeric.
         # This is where the bulk (75%) of the time is spent in this module, so
         # try to make it fast!
         */
        // NOTE: Instead of returning undef, it returns -1.
        int ReplaceNextLargerWith(IntList array, int value, int high)
        {
            if (high <= 0)
            {
                high = array.Count - 1;
            }

            // off the end?
            if (high == -1 || value > array[array.Count - 1])
            {
                array.Add(value);
                return(array.Count - 1);
            }

            // binary search for insertion point...
            int low = 0;

            while (low <= high)
            {
                int index = (high + low) / 2;

                int found = array[index];

                if (value == found)
                {
                    return(-1);
                }

                if (value > found)
                {
                    low = index + 1;
                }
                else
                {
                    high = index - 1;
                }
            }

            // # now insertion point is in $low.
            array[low] = value;    // overwrite next larger
            return(low);
        }
예제 #7
0
        IntList compact_diff(IList a, IList b)
        {
            IntList am, bm;

            LongestCommonSubsequenceIndex(a, b, out am, out bm);
            IntList newCompactDiff = new IntList();
            int     ai = 0, bi = 0;

            newCompactDiff.Add(ai);
            newCompactDiff.Add(bi);
            while (true)
            {
                while (am.Count > 0 && ai == am[0] && bi == bm[0])
                {
                    am.RemoveAt(0);
                    bm.RemoveAt(0);
                    ++ai;
                    ++bi;
                }

                newCompactDiff.Add(ai);
                newCompactDiff.Add(bi);
                if (am.Count == 0)
                {
                    break;
                }
                ai = am[0];
                bi = bm[0];
                newCompactDiff.Add(ai);
                newCompactDiff.Add(bi);
            }

            if (ai < a.Count || bi < b.Count)
            {
                newCompactDiff.Add(a.Count);
                newCompactDiff.Add(b.Count);
            }

            return(newCompactDiff);
        }
예제 #8
0
        IntList compact_diff(IList a, IList b)
        {
            IntList am, bm, cdiff;

            LCSidx(a, b, out am, out bm);
            cdiff = new IntList();
            int ai = 0, bi = 0;

            cdiff.Add(ai);
            cdiff.Add(bi);
            while (true)
            {
                while (am.Count > 0 && ai == (int)am[0] && bi == (int)bm[0])
                {
                    am.RemoveAt(0);
                    bm.RemoveAt(0);
                    ++ai;
                    ++bi;
                }

                cdiff.Add(ai);
                cdiff.Add(bi);
                if (am.Count == 0)
                {
                    break;
                }
                ai = (int)am[0];
                bi = (int)bm[0];
                cdiff.Add(ai);
                cdiff.Add(bi);
            }

            if (ai < a.Count || bi < b.Count)
            {
                cdiff.Add(a.Count);
                cdiff.Add(b.Count);
            }

            return(cdiff);
        }
예제 #9
0
        private IntList compact_diff(IList a, IList b)
        {
            IntList am;
            IntList bm;

            this.LCSidx(a, b, out am, out bm);
            IntList list3 = new IntList();
            int     num   = 0;
            int     num2  = 0;

            list3.Add(num);
            list3.Add(num2);
            while (true)
            {
                while (((am.Count > 0) && (num == am[0])) && (num2 == bm[0]))
                {
                    am.RemoveAt(0);
                    bm.RemoveAt(0);
                    num++;
                    num2++;
                }
                list3.Add(num);
                list3.Add(num2);
                if (am.Count == 0)
                {
                    break;
                }
                num  = am[0];
                num2 = bm[0];
                list3.Add(num);
                list3.Add(num2);
            }
            if ((num < a.Count) || (num2 < b.Count))
            {
                list3.Add(a.Count);
                list3.Add(b.Count);
            }
            return(list3);
        }
예제 #10
0
        private Hashtable _withPositionsOfInInterval(IList aCollection, int start, int end)
        {
            Hashtable hashtable = new Hashtable(this.hashcoder);

            for (int i = start; i <= end; i++)
            {
                object key = aCollection[i];
                if (hashtable.ContainsKey(key))
                {
                    ((IntList)hashtable[key]).Add(i);
                }
                else
                {
                    IntList list2 = new IntList();
                    list2.Add(i);
                    hashtable[key] = list2;
                }
            }
            foreach (IntList list3 in hashtable.Values)
            {
                list3.Reverse();
            }
            return(hashtable);
        }
예제 #11
0
        IntList _longestCommonSubsequence(IList a, IList b)
        {
            int aStart = 0;
            int aFinish = a.Count-1;
            IntList matchVector = new IntList();
            Hashtable bMatches;

            // initialize matchVector to length of a
            for (int i = 0; i < a.Count; i++)
                matchVector.Add(-1);

            if (!IsPrepared(out bMatches)) {
                int bStart = 0;
                int bFinish = b.Count-1;

                // First we prune off any common elements at the beginning
                while (aStart <= aFinish && bStart <= bFinish && compare(a[aStart], b[bStart]))
                    matchVector[aStart++] = bStart++;

                // now the end
                while (aStart <= aFinish && bStart <= bFinish && compare(a[aFinish], b[bFinish]))
                    matchVector[aFinish--] = bFinish--;

                // Now compute the equivalence classes of positions of elements
                bMatches =
                  _withPositionsOfInInterval(b, bStart, bFinish);
            }

            IntList thresh = new IntList();
            TrioList links = new TrioList();

            for (int i = aStart; i <= aFinish; i++) {
                IntList aimatches = (IntList)bMatches[a[i]];
                if (aimatches != null) {
                    int k = 0;
                    for (int ji = 0; ji < aimatches.Count; ji++) {
                        int j = aimatches[ji];
                        // # optimization: most of the time this will be true
                        if (k>0 && (int)thresh[k] > j && (int)thresh[k-1] < j)
                            thresh[k] = j;
                        else
                            k = _replaceNextLargerWith(thresh, j, k);

                        // oddly, it's faster to always test this (CPU cache?).
                        if (k != -1) {
                            Trio t = new Trio( (Trio)( k>0 ? links[k-1] : null ), i, j );
                            if (k == links.Count)
                                links.Add( t );
                            else
                                links[k] = t;
                        }
                    }
                }
            }

            if (thresh.Count > 0) {
                for (Trio link = (Trio)links[thresh.Count-1]; link != null; link = link.a)
                    matchVector[link.b] = link.c;
            }

            return matchVector;
        }
예제 #12
0
        void init()
        {
            cdif = compact_diff(left, right);
            _Same = true;
            if (0 == (int)cdif[2] && 0 == (int)cdif[3]) {
                _Same = false;
                cdif.RemoveAt(0);
                cdif.RemoveAt(0);
            }

            _End = (1+cdif.Count)/2;
        }
예제 #13
0
 /*void prepare(IList list) {
     prepared = _withPositionsOfInInterval(list, 0, list.Count-1);
     preparedlist = list;
 }*/
 void LCSidx(IList a, IList b, out IntList am, out IntList bm)
 {
     IntList match = _longestCommonSubsequence(a, b);
     am = new IntList();
     for (int i = 0; i < match.Count; i++)
         if ((int)match[i] != -1)
             am.Add(i);
     bm = new IntList();
     for (int vi = 0; vi < am.Count; vi++)
         bm.Add(match[am[vi]]);
 }
예제 #14
0
        IntList compact_diff(IList a, IList b)
        {
            IntList am, bm, cdiff;
            LCSidx(a, b, out am, out bm);
            cdiff = new IntList();
            int ai = 0, bi = 0;
            cdiff.Add(ai);
            cdiff.Add(bi);
            while (true) {
                while(am.Count > 0 && ai == (int)am[0] && bi == (int)bm[0]) {
                    am.RemoveAt(0);
                    bm.RemoveAt(0);
                    ++ai;
                    ++bi;
                }

                cdiff.Add(ai);
                cdiff.Add(bi);
                if (am.Count == 0) break;
                ai = (int)am[0];
                bi = (int)bm[0];
                cdiff.Add(ai);
                cdiff.Add(bi);
            }

            if (ai < a.Count || bi < b.Count) {
                cdiff.Add(a.Count);
                cdiff.Add(b.Count);
            }

            return cdiff;
        }
예제 #15
0
        private IntList _longestCommonSubsequence(IList a, IList b)
        {
            Hashtable bMatches;
            int       num  = 0;
            int       num2 = a.Count - 1;
            IntList   list = new IntList();

            for (int i = 0; i < a.Count; i++)
            {
                list.Add(-1);
            }
            if (!this.IsPrepared(out bMatches))
            {
                int start = 0;
                int end   = b.Count - 1;
                while (((num <= num2) && (start <= end)) && this.compare(a[num], b[start]))
                {
                    list[num++] = start++;
                }
                while (((num <= num2) && (start <= end)) && this.compare(a[num2], b[end]))
                {
                    list[num2--] = end--;
                }
                bMatches = this._withPositionsOfInInterval(b, start, end);
            }
            IntList   array = new IntList();
            ArrayList list3 = new ArrayList();

            for (int j = num; j <= num2; j++)
            {
                IntList list4 = (IntList)bMatches[a[j]];
                if (list4 != null)
                {
                    int high = 0;
                    for (int k = 0; k < list4.Count; k++)
                    {
                        int num9 = list4[k];
                        if (((high > 0) && (array[high] > num9)) && (array[high - 1] < num9))
                        {
                            array[high] = num9;
                        }
                        else
                        {
                            high = this._replaceNextLargerWith(array, num9, high);
                        }
                        if (high != -1)
                        {
                            Trio trio = new Trio((high > 0) ? ((Trio)list3[high - 1]) : null, j, num9);
                            if (high == list3.Count)
                            {
                                list3.Add(trio);
                            }
                            else
                            {
                                list3[high] = trio;
                            }
                        }
                    }
                }
            }
            if (array.Count > 0)
            {
                for (Trio trio2 = (Trio)list3[array.Count - 1]; trio2 != null; trio2 = trio2.a)
                {
                    list[trio2.b] = trio2.c;
                }
            }
            return(list);
        }
예제 #16
0
        IntList compact_diff(IList a, IList b)
        {
            IntList am, bm;
            LongestCommonSubsequenceIndex(a, b, out am, out bm);
            IntList newCompactDiff = new IntList();
            int ai = 0, bi = 0;
            newCompactDiff.Add(ai);
            newCompactDiff.Add(bi);
            while (true)
            {
                while (am.Count > 0 && ai == am[0] && bi == bm[0])
                {
                    am.RemoveAt(0);
                    bm.RemoveAt(0);
                    ++ai;
                    ++bi;
                }

                newCompactDiff.Add(ai);
                newCompactDiff.Add(bi);
                if (am.Count == 0) break;
                ai = am[0];
                bi = bm[0];
                newCompactDiff.Add(ai);
                newCompactDiff.Add(bi);
            }

            if (ai < a.Count || bi < b.Count)
            {
                newCompactDiff.Add(a.Count);
                newCompactDiff.Add(b.Count);
            }

            return newCompactDiff;
        }
예제 #17
0
        void init()
        {
            compactDiff = compact_diff(left, right);
            same = true;
            if (0 == compactDiff[2] && 0 == compactDiff[3])
            {
                same = false;
                compactDiff.RemoveAt(0);
                compactDiff.RemoveAt(0);
            }

            end = (1 + compactDiff.Count) / 2;
        }
예제 #18
0
        /*
        # Find the place at which aValue would normally be inserted into the
        # array. If that place is already occupied by aValue, do nothing, and
        # return undef. If the place does not exist (i.e., it is off the end of
        # the array), add it to the end, otherwise replace the element at that
        # point with aValue.  It is assumed that the array's values are numeric.
        # This is where the bulk (75%) of the time is spent in this module, so
        # try to make it fast!
        */
        // NOTE: Instead of returning undef, it returns -1.
        int _replaceNextLargerWith(IntList array, int value, int high)
        {
            if (high <= 0)
                high = array.Count-1;

            // off the end?
            if (high == -1 || value > (int)array[array.Count-1]) {
                array.Add(value);
                return array.Count-1;
            }

            // binary search for insertion point...
            int low = 0;
            int index, found;
            while (low <= high) {
                index = (high + low) / 2;

                found = (int)array[index];

                if (value == found)
                    return -1;
                else if (value > found)
                    low = index + 1;
                else
                    high = index - 1;
            }

            // # now insertion point is in $low.
            array[low] = value;    // overwrite next larger
            return low;
        }
예제 #19
0
        /*
        # McIlroy-Hunt diff algorithm
        # Adapted from the Smalltalk code of Mario I. Wolczko, <*****@*****.**>
        # by Ned Konz, [email protected]
        # Updates by Tye McQueen, http://perlmonks.org/?node=tye

        # Create a hash that maps each element of $aCollection to the set of
        # positions it occupies in $aCollection, restricted to the elements
        # within the range of indexes specified by $start and $end.
        # The fourth parameter is a subroutine reference that will be called to
        # generate a string to use as a key.
        # Additional parameters, if any, will be passed to this subroutine.
        #
        # my $hashRef = _withPositionsOfInInterval( \@array, $start, $end, $keyGen );
        */
        Hashtable _withPositionsOfInInterval(IList aCollection, int start, int end)
        {
            Hashtable d = new Hashtable(hashcoder, comparer);
            for (int index = start; index <= end; index++) {
                object element = aCollection[index];
                if (d.ContainsKey(element)) {
                    IntList list = (IntList)d[element];
                    list.Add(index);
                } else {
                    IntList list = new IntList();
                    list.Add(index);
                    d[element] = list;
                }
            }
            foreach (IntList list in d.Values)
                list.Reverse();
            return d;
        }
예제 #20
0
        IntList LongestCommonSubsequence(IList a, IList b)
        {
            int       aStart      = 0;
            int       aFinish     = a.Count - 1;
            IntList   matchVector = new IntList();
            Hashtable bMatches;

            // initialize matchVector to length of a
            for (int i = 0; i < a.Count; i++)
            {
                matchVector.Add(-1);
            }

            if (!IsPrepared(out bMatches))
            {
                int bStart  = 0;
                int bFinish = b.Count - 1;

                // First we prune off any common elements at the beginning
                while (aStart <= aFinish && bStart <= bFinish && compare(a[aStart], b[bStart]))
                {
                    matchVector[aStart++] = bStart++;
                }

                // now the end
                while (aStart <= aFinish && bStart <= bFinish && compare(a[aFinish], b[bFinish]))
                {
                    matchVector[aFinish--] = bFinish--;
                }

                // Now compute the equivalence classes of positions of elements
                bMatches =
                    WithPositionsOfInInterval(b, bStart, bFinish);
            }

            IntList  thresh = new IntList();
            TrioList links  = new TrioList();

            for (int i = aStart; i <= aFinish; i++)
            {
                IntList aimatches = (IntList)bMatches[a[i]];
                if (aimatches != null)
                {
                    int k = 0;
                    for (int ji = 0; ji < aimatches.Count; ji++)
                    {
                        int j = aimatches[ji];
                        // # optimization: most of the time this will be true
                        if (k > 0 && thresh[k] > j && thresh[k - 1] < j)
                        {
                            thresh[k] = j;
                        }
                        else
                        {
                            k = ReplaceNextLargerWith(thresh, j, k);
                        }

                        // oddly, it's faster to always test this (CPU cache?).
                        if (k != -1)
                        {
                            Trio t = new Trio((Trio)(k > 0 ? links[k - 1] : null), i, j);
                            if (k == links.Count)
                            {
                                links.Add(t);
                            }
                            else
                            {
                                links[k] = t;
                            }
                        }
                    }
                }
            }

            if (thresh.Count > 0)
            {
                for (Trio link = (Trio)links[thresh.Count - 1]; link != null; link = link.a)
                {
                    matchVector[link.b] = link.c;
                }
            }

            return(matchVector);
        }