Compare 0177850 ... +45 ... a0c8ffe

#' \code{ses_dat} includes matching values whereas \code{ses} does not.  See

#' examples.

#'   as a \code{data.frame} with columns \code{op} (factor, values

#'   \dQuote{Match}, \dQuote{Insert}, or \dQuote{Delete}), \code{val} character

#'   corresponding to the value taken from either \code{a} or \code{b},

#'   and if \code{extra} is TRUE, integer columns \code{id.a} and \code{id.b}

#'   corresponding to the indices in \code{a} or \code{b} that \code{val} was

#'   taken from.  See Details.

  if(extra) {

#'   zero to allow as many as there are

diff_myers <- function(a, b, max.diffs=0L, warn=FALSE) {

      } else x

 * - Adding lots of comments as we worked through the logic

 * k = diagonal number

 * val = x value

 * r = presumably whether we are looking up in reverse snakes

 * path we've found.  Use `r` to look for the x coordinate for the paths that

 * are starting from the bottom right instead of top left

 * of string, but not sure if that is intentional or not.  In theory it should

 * not be, but perhaps this was handled gracefully by the varray business b4

 * we changed it.

    comp = 0;

 * General logic is to create a faux snake that instead of moving down

 * diagonally will chain right and down moves until it hits a path coming

 * from the other direction.  This snake is stored in `ctx`, and is then

 * written by `ses` to the `ses` list.

  SEXP a, int aoff, int n, SEXP b, int boff, int m, struct _ctx *ctx,

  struct middle_snake *ms, int d, diff_op ** faux_snake

  /* normally we would record k/x values at the end of the furthest reaching

   * snake, but here we need pick a path from top left  and extend it until

   * we hit something coming from bottom right.

   */

  /* start by finding which diagonal has the furthest reaching value

   * when looking from top left

   */

  int k_max_f = 0, x_max_f = -1;

  int x_f, y_f, k_f;

  int delta = n - m;

  for (int k = d - 1; k >= -d + 1; k -= 2) { /* might need to shift by 1 */

    int x_f = FV(k);

    int f_dist = x_f - abs(k);

    if(x_f > n || x_f - k > m) continue;

    if(f_dist > x_max_f - abs(k_max_f)) {

      x_max_f = x_f;

      k_max_f = k;

    }

  }

  /* didn't find a path so use origin */

  if(x_max_f < 0) {

    // nocov start

    error(err_msg_ubrnch, 2);

    x_f = y_f = k_f = 0;

    // nocov end

  } else {

    k_f = k_max_f;

    x_f = x_max_f;

    y_f = x_f - k_max_f;

  }

  /*

   * now look for the furthest reaching point in any diagonal that is

   * below the diagonal we found above since those are the only ones we

   * can connect to

   *

   */

  int k_max_r = 0, x_max_r = n + 1;

  int x_r, y_r;

  for (int k = -d; k <= k_max_f - delta; k += 2) {

    int x_r = RV(k);

    int r_dist = n - x_r - abs(k);

    /* skip reverse snakes that overshoot our forward snake

     * ---\

     *     \

     *   \

     *    \

     *     \---

     * where there should be a decent path we can use, but because we are only

     * tracking the last coordinates we don't really have a way connecting this

     * type of path so we just go straight to the origin even though that is

     * even more sub-optinal; not even sure if this is a possible scenario

     */

    if(x_r < x_f || x_r - k - delta < y_f) continue;

    /* since buffer is init to zero, an x_r value of zero means nothing, and

     * not all the way to the left of the graph; also, in reverse snakes the

     * snake should end at x == 1 in the leftmost case (we think)

     */

    if(r_dist > n - x_max_r - abs(k_max_r) && x_r) {

      x_max_r = x_r;

      k_max_r = k;

    }

  }

  if(x_max_r >= n) {

    x_r = n; y_r = m;

  } else {

    x_r = x_max_r;

    /* not 100% sure about this one; seems like k_max_r is relative to the

     * bottom right origin, so maybe this should be x_r - k_max_r - delta?

     */

    y_r = x_r - k_max_r - delta;

  }

  /*

   * attempt to connect the two paths we found.  We need to store this

   * information as our "faux" snake since it will have to be processed

   * in a manner similar as the middle snake would be processed; start by

   * figuring out max number of steps it would take to connect the two

   * paths

   */

  int max_steps = x_r - x_f + y_r - y_f + 1;

  int diffs = 0;

  int x_sn = x_f, y_sn = y_f;

  /* initialize the fake snake */

  if(max_steps < 0)

  /* we have a further reaching reverse snake:

   * not entirely sure if this should happen, but it seems it does

   */

  while(x_sn < x_r || y_sn < y_r) {

    if(x_sn > x_r || y_sn > y_r) {

      error("Logic Error: Exceeded buffer for finding fake snake; contact maintainer.");  // nocov

    }

    /* check to see if we could possibly move on a diagonal, and do so

     * if possible, if not alternate going down and right*/

        x_sn <= x_r && y_sn <= y_r &&

        _comp_chr(a, aoff + x_sn, b, boff + y_sn)

      x_sn++; y_sn++;

    } else if (x_sn < x_r && (step_dir || y_sn >= y_r)) {

      x_sn++;

    } else if (y_sn < y_r && (!step_dir || x_sn >= x_r)) {

      y_sn++;

  /* corner cases; must absolutely make sure steps LT max_steps since we rely

   * on at least one zero at the end of the faux_snake when we read it to know

   * to stop reading it

   */

  if(x_sn != x_r || y_sn != y_r || steps >= max_steps) {

  /* modify the pointer to the pointer so we can return in by ref */

  /* record the coordinates of our faux snake using `ms` */

  ms->x = x_f;

  ms->y = y_f;

  ms->u = x_r;

  ms->v = y_r;

  mid = (n + m) / 2;

    /* reached maximum allowable differences before real exit condition*/

    if ((2 * d - 1) >= ctx->dmax) {

      return _find_faux_snake(a, aoff, n, b, boff, m, ctx, ms, d, faux_snake);

    /* Forward (from top left) paths*/

        x = FV(k + 1);

        x = FV(k - 1) + 1;

        /* matching characters, just walk down diagonal */

        x++; y++;

      /* for this diagonal we (think we) are now at farthest reaching point for

       * a given d.  Then return if:

       * - If we're at the edge of the addressable part of the graph

       * - The reverse snakes are already overlapping in the `x` coordinate

       * then it means that the only way to get to the snake coming from the

       * other direction is by either moving down or across for every remaining

       * move, so record the current coord as `u` and `v` and return

       * Note that for the backward snake we reverse xy and uv so that the

       * matching snake is always defined in `ms` as starting at `ms.(xy)` and

       * ending at `ms.(uv)`

    /* Backwards (from bottom right) paths*/

  //Rprintf("m: %d n: %d\n", m, n);

    /* Find the middle "snake" around which we

     * recursively solve the sub-problems.  Note this modifies `ms` by ref to

     * set the beginning and end coordinates of the snake of the furthest

     * reaching path.  The beginning is always the top left part of the snake,

     * irrespective of whether it was found on a forward or reverse path as

     * f_m_s will flip the coordinates when appropriately when recording them

     * in `ms`

    //

    // d

    // diff_op * fsp = NULL;

    // diff_op fsv = DIFF_NULL;

    // *fsp = fsv;

    // **faux_snake = *fsp;

    //Rprintf("d: %d\n", d);

    } else if (d > 1) {

      if (_ses(a, aoff, n, b, boff, m, ctx) == -1) {

    } else {

      /* There are only 4 base cases when the

       * edit distance is 1.  Having a hard time finding cases that trigger the

       * x == u, possibly because the algo eats leading matches, although

       * apparently we do achieve it somewhere in the test suite.

      //Rprintf("x: %d u: %d y: %d v: %d\n",  ms.x, ms.u, ms.y, ms.v);

          "Very special case n %d m %d aoff %d boff %d u %d\n", n, m,

          aoff, boff, ms.u

  if(bufmax < n || bufmax < m)

    error("Logic Error: exceeded maximum allowable combined string length.");  // nocov

  ctx.dmax = dmax ? dmax : INT_MAX;

    if(boff > INT_MAX - y)

      error("Internal error: overflow for boff; contact maintainer"); //nocov

    if(aoff > INT_MAX - x)

      error("Internal error: overflow for aoff; contact maintainer"); //nocov

#' comparison to avoid spurious encoding-only differences.

#' @param max.diffs integer(1L), number of \emph{differences} after which we

#'   abandon the \code{O(n^2)} diff algorithm in favor of a naive element by

#'   element comparison. Set to \code{-1L} to always stick to the original

#'   algorithm (defaults to 50000L).

  if(max_i < 0) max_i = 0;