Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2006 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
 
 package org.eclipse.compare.internal;
 
 
 /* Used to determine the change set responsible for each line */
 public abstract class LCS {
 
     private int max_differences// the maximum number of differences
 
     // from
 
     // each end to consider
 
     private int length;

    
Myers' algorithm for longest common subsequence. O((M + N)D) worst case time, O(M + N + D^2) expected time, O(M + N) space (http://citeseer.ist.psu.edu/myers86ond.html) Note: Beyond implementing the algorithm as described in the paper I have added diagonal range compression which helps when finding the LCS of a very long and a very short sequence, also bound the running time to (N + M)^1.5 when both sequences are very long. After this method is called, the longest common subsequence is available by calling getResult() where result[0] is composed of entries from l1 and result[1] is composed of entries from l2

Parameters:
subMonitor
 
     public void longestCommonSubsequence(LCSSettings settings) {
         int length1 = getLength1();
         int length2 = getLength2();
         if (length1 == 0 || length2 == 0) {
              = 0;
             return;
         }
 
          = (length1 + length2 + 1) / 2; // ceil((N+M)/2)
         if ((doublelength1 * (doublelength2 > settings.getTooLong()) {
             // limit complexity to D^POW_LIMIT for long sequences
              = (int) Math.pow(settings
                     .getPowLimit() - 1.0);
         }
 
         initializeLcs(length1);
 
         /*
          * The common prefixes and suffixes are always part of some LCS, include
          * them now to reduce our search space
          */
         int forwardBound;
         int max = Math.min(length1length2);
         for (forwardBound = 0; forwardBound < max
                 && isRangeEqual(forwardBoundforwardBound); forwardBound++) {
             setLcs(forwardBoundforwardBound);
         }
 
         int backBoundL1 = length1 - 1;
         int backBoundL2 = length2 - 1;
 
         while (backBoundL1 >= forwardBound && backBoundL2 >= forwardBound
                 && isRangeEqual(backBoundL1backBoundL2)) {
             setLcs(backBoundL1backBoundL2);
             backBoundL1--;
             backBoundL2--;
         }
 
          = forwardBound
                 + length1
                 - backBoundL1
                 - 1
                 + lcs_rec(forwardBoundbackBoundL1forwardBoundbackBoundL2,
                         new int[2][length1 + length2 + 1], new int[3]);
 
     }

    
The recursive helper function for Myers' LCS. Computes the LCS of l1[bottoml1 .. topl1] and l2[bottoml2 .. topl2] fills in the appropriate location in lcs and returns the length

Parameters:
l1 The 1st sequence
bottoml1 Index in the 1st sequence to start from (inclusive)
topl1 Index in the 1st sequence to end on (inclusive)
l2 The 2nd sequence
bottoml2 Index in the 2nd sequence to start from (inclusive)
topl2 Index in the 2nd sequence to end on (inclusive)
V should be allocated as int[2][l1.length + l2.length + 1], used to store furthest reaching D-paths
snake should be allocated as int[3], used to store the beginning x, y coordinates and the length of the latest snake traversed
subMonitor
lcs should be allocated as TextLine[2][l1.length], used to store the common points found to be part of the LCS where lcs[0] references lines of l1 and lcs[1] references lines of l2.
Returns:
the length of the LCS
    private int lcs_rec(int bottoml1int topl1int bottoml2int topl2,
            int[][] Vint[] snake) {
        // check that both sequences are non-empty
        if (bottoml1 > topl1 || bottoml2 > topl2) {
            return 0;
        }
        int d = find_middle_snake(bottoml1topl1bottoml2topl2Vsnake);
        // System.out.println(snake[0] + " " + snake[1] + " " + snake[2]);
        // need to store these so we don't lose them when they're overwritten by
        // the recursion
        int len = snake[2];
        int startx = snake[0];
        int starty = snake[1];
        // the middle snake is part of the LCS, store it
        for (int i = 0; i < leni++) {
            setLcs(startx + istarty + i);
        }
        if (d > 1) {
            return len
                    + lcs_rec(bottoml1startx - 1, bottoml2starty - 1, V,
                            snake)
                    + lcs_rec(startx + lentopl1starty + lentopl2V,
                            snake);
        } else if (d == 1) {
            /*
             * In this case the sequences differ by exactly 1 line. We have
             * already saved all the lines after the difference in the for loop
             * above, now we need to save all the lines before the difference.
             */
            int max = Math.min(startx - bottoml1starty - bottoml2);
            for (int i = 0; i < maxi++) {
                setLcs(bottoml1 + ibottoml2 + i);
            }
            return max + len;
        }
        return len;
    }

    
Helper function for Myers' LCS algorithm to find the middle snake for l1[bottoml1..topl1] and l2[bottoml2..topl2] The x, y coodrdinates of the start of the middle snake are saved in snake[0], snake[1] respectively and the length of the snake is saved in s[2].

Parameters:
l1 The 1st sequence
bottoml1 Index in the 1st sequence to start from (inclusive)
topl1 Index in the 1st sequence to end on (inclusive)
l2 The 2nd sequence
bottoml2 Index in the 2nd sequence to start from (inclusive)
topl2 Index in the 2nd sequence to end on (inclusive)
V should be allocated as int[2][l1.length + l2.length + 1], used to store furthest reaching D-paths
snake should be allocated as int[3], used to store the beginning x, y coordinates and the length of the middle snake
Returns:
The number of differences (SES) between l1[bottoml1..topl1] and l2[bottoml2..topl2]
    private int find_middle_snake(int bottoml1int topl1int bottoml2,
            int topl2int[][] Vint[] snake) {
        int N = topl1 - bottoml1 + 1;
        int M = topl2 - bottoml2 + 1;
        // System.out.println("N: " + N + " M: " + M + " bottom: " + bottoml1 +
        // ", " +
        // bottoml2 + " top: " + topl1 + ", " + topl2);
        int delta = N - M;
        boolean isEven;
        if ((delta & 1) == 1) {
            isEven = false;
        } else {
            isEven = true;
        }
        int limit = Math.min(, (N + M + 1) / 2); // ceil((N+M)/2)
        int value_to_add_forward// a 0 or 1 that we add to the start
        // offset
        // to make it odd/even
        if ((M & 1) == 1) {
            value_to_add_forward = 1;
        } else {
            value_to_add_forward = 0;
        }
        int value_to_add_backward;
        if ((N & 1) == 1) {
            value_to_add_backward = 1;
        } else {
            value_to_add_backward = 0;
        }
        int start_forward = -M;
        int end_forward = N;
        int start_backward = -N;
        int end_backward = M;
        V[0][limit + 1] = 0;
        V[1][limit - 1] = N;
        for (int d = 0; d <= limitd++) {
            int start_diag = Math.max(value_to_add_forward + start_forward, -d);
            int end_diag = Math.min(end_forwardd);
            value_to_add_forward = 1 - value_to_add_forward;
            // compute forward furthest reaching paths
            for (int k = start_diagk <= end_diagk += 2) {
                int x;
                if (k == -d
                        || (k < d && V[0][limit + k - 1] < V[0][limit + k + 1])) {
                    x = V[0][limit + k + 1];
                } else {
                    x = V[0][limit + k - 1] + 1;
                }
                int y = x - k;
                snake[0] = x + bottoml1;
                snake[1] = y + bottoml2;
                snake[2] = 0;
                // System.out.println("1 x: " + x + " y: " + y + " k: " + k + "
                // d: " + d );
                while (x < N && y < M
                        && isRangeEqual(x + bottoml1y + bottoml2)) {
                    x++;
                    y++;
                    snake[2]++;
                }
                V[0][limit + k] = x;
                // System.out.println(x + " " + V[1][limit+k -delta] + " " + k +
                // " " + delta);
                if (!isEven && k >= delta - d + 1 && k <= delta + d - 1
                        && x >= V[1][limit + k - delta]) {
                    // System.out.println("Returning: " + (2*d-1));
                    return 2 * d - 1;
                }
                // check to see if we can cut down the diagonal range
                if (x >= N && end_forward > k - 1) {
                    end_forward = k - 1;
                } else if (y >= M) {
                    start_forward = k + 1;
                    value_to_add_forward = 0;
                }
            }
            start_diag = Math.max(value_to_add_backward + start_backward, -d);
            end_diag = Math.min(end_backwardd);
            value_to_add_backward = 1 - value_to_add_backward;
            // compute backward furthest reaching paths
            for (int k = start_diagk <= end_diagk += 2) {
                int x;
                if (k == d
                        || (k != -d && V[1][limit + k - 1] < V[1][limit + k + 1])) {
                    x = V[1][limit + k - 1];
                } else {
                    x = V[1][limit + k + 1] - 1;
                }
                int y = x - k - delta;
                snake[2] = 0;
                // System.out.println("2 x: " + x + " y: " + y + " k: " + k + "
                // d: " + d);
                while (x > 0 && y > 0
                        && isRangeEqual(x - 1 + bottoml1y - 1 + bottoml2)) {
                    x--;
                    y--;
                    snake[2]++;
                }
                V[1][limit + k] = x;
                if (isEven && k >= -delta - d && k <= d - delta
                        && x <= V[0][limit + k + delta]) {
                    // System.out.println("Returning: " + 2*d);
                    snake[0] = bottoml1 + x;
                    snake[1] = bottoml2 + y;
                    return 2 * d;
                }
                // check to see if we can cut down our diagonal range
                if (x <= 0) {
                    start_backward = k + 1;
                    value_to_add_backward = 0;
                } else if (y <= 0 && end_backward > k - 1) {
                    end_backward = k - 1;
                }
            }
        }
        /*
         * computing the true LCS is too expensive, instead find the diagonal
         * with the most progress and pretend a midle snake of length 0 occurs
         * there.
         */
        int[] most_progress = findMostProgress(MNlimitV);
        snake[0] = bottoml1 + most_progress[0];
        snake[1] = bottoml2 + most_progress[1];
        snake[2] = 0;
        return 5; /*
                     * HACK: since we didn't really finish the LCS computation
                     * we don't really know the length of the SES. We don't do
                     * anything with the result anyway, unless it's <=1. We know
                     * for a fact SES > 1 so 5 is as good a number as any to
                     * return here
                     */
    }

    
Takes the array with furthest reaching D-paths from an LCS computation and returns the x,y coordinates and progress made in the middle diagonal among those with maximum progress, both from the front and from the back.

Parameters:
M the length of the 1st sequence for which LCS is being computed
N the length of the 2nd sequence for which LCS is being computed
limit the number of steps made in an attempt to find the LCS from the front and back
V the array storing the furthest reaching D-paths for the LCS computation
Returns:
The result as an array of 3 integers where result[0] is the x coordinate of the current location in the diagonal with the most progress, result[1] is the y coordinate of the current location in the diagonal with the most progress and result[2] is the amount of progress made in that diagonal
    private static int[] findMostProgress(int Mint Nint limitint[][] V) {
        int delta = N - M;
        int forward_start_diag;
        if ((M & 1) == (limit & 1)) {
            forward_start_diag = Math.max(-M, -limit);
        } else {
            forward_start_diag = Math.max(1 - M, -limit);
        }
        int forward_end_diag = Math.min(Nlimit);
        int backward_start_diag;
        if ((N & 1) == (limit & 1)) {
            backward_start_diag = Math.max(-N, -limit);
        } else {
            backward_start_diag = Math.max(1 - N, -limit);
        }
        int backward_end_diag = Math.min(Mlimit);
        int[][] max_progress = new int[Math.max(forward_end_diag
                - forward_start_diagbackward_end_diag - backward_start_diag) / 2 + 1][3];
        int num_progress = 0; // the 1st entry is current, it is initialized
        // with 0s
        // first search the forward diagonals
        for (int k = forward_start_diagk <= forward_end_diagk += 2) {
            int x = V[0][limit + k];
            int y = x - k;
            if (x > N || y > M) {
                continue;
            }
            int progress = x + y;
            if (progress > max_progress[0][2]) {
                num_progress = 0;
                max_progress[0][0] = x;
                max_progress[0][1] = y;
                max_progress[0][2] = progress;
            } else if (progress == max_progress[0][2]) {
                num_progress++;
                max_progress[num_progress][0] = x;
                max_progress[num_progress][1] = y;
                max_progress[num_progress][2] = progress;
            }
        }
        boolean max_progress_forward = true// initially the maximum
        // progress is in the forward
        // direction
        // now search the backward diagonals
        for (int k = backward_start_diagk <= backward_end_diagk += 2) {
            int x = V[1][limit + k];
            int y = x - k - delta;
            if (x < 0 || y < 0) {
                continue;
            }
            int progress = N - x + M - y;
            if (progress > max_progress[0][2]) {
                num_progress = 0;
                max_progress_forward = false;
                max_progress[0][0] = x;
                max_progress[0][1] = y;
                max_progress[0][2] = progress;
            } else if (progress == max_progress[0][2] && !max_progress_forward) {
                num_progress++;
                max_progress[num_progress][0] = x;
                max_progress[num_progress][1] = y;
                max_progress[num_progress][2] = progress;
            }
        }
        // return the middle diagonal with maximal progress.
        return max_progress[num_progress / 2];
    }
    protected abstract int getLength2();
    protected abstract int getLength1();
    protected abstract boolean isRangeEqual(int i1int i2);
    protected abstract void setLcs(int sl1int sl2);
    protected abstract void initializeLcs(int lcsLength);
    public int getLength() {
        return ;
    }
New to GrepCode? Check out our FAQ X