How to know two lines are a pare parallel lines

Discussion in 'C Programming' started by lovecreatesbeauty, Apr 27, 2006.

  1. For example, line L1 and line L2 are two lines in two-dimensional
    space, the start-points and end-points can be described with following
    the `point_t' type. The start-points and end-points are: Line L1
    (L1_str, L1_end), L2 (L2_str, L2_end).

    Can I compare the float value of sloping rate of two lines to determine
    whether they are parallel lines? Some paper books tell that float value
    can not be compared to float value. Some people also try to convince
    others on this point that do not perform the comparing on float values.
    Then how can I complete the task of determining whether two lines are
    parallel lines by their sloping rate?

    /* type for points */
    typedef struct
    double x;
    double y;
    } point_t;

    /* calculate the value of sloping rate of a line */
    double slope(point_t pt_start, point_t pt_end);

    double sl_L1 = slope (L1_str, L1_end);
    double s2_L2 = slope (L2_str, L2_end);

    if (s1_L1 == s2_L2) /* CAUTION: compare float data to float, is it ok?
    /* L1 and L2 are parallel lines */
    /* L1 and L2 are not parallel lines */
    lovecreatesbeauty, Apr 27, 2006
    1. Advertisements

  2. You simply need to determine how close to numerical equality the slopes
    need to be to count as parallel. This will tell whether, within the
    constraints of your measurements and arithmetic precision, you can tell
    whether the lines are not parallel. You can never tell that they are
    actually parallel when any of the values involved are not expressible
    exactly as floating point values. Notice that if your points are
    expressible in integral or even rational terms, then you may be able to
    avoid floating point representations entirely.
    Martin Ambuhl, Apr 27, 2006
    1. Advertisements

  3. lovecreatesbeauty

    osmium Guest


    It is common to compare two floating point numbers to see whether they are
    within a "guard band" of one another. An elementary way would be to create
    a constant such as this:

    const double epsilon = 1.0e-06;

    And then see if two numbers are equal + or - one epsilon. For more advanced
    usage you could actually compute epsilon so it had some relationship to the
    problem you are solving. For example, if you are dealing with the distance
    to Pluto and the distance is in centimeters, epsilon might be bigger.
    osmium, Apr 27, 2006
  4. The question implicitly assumes that you need to distinguish the
    "very-nearly" parallel lines from the "exactly" parallel lines.
    That in turn assumes that the coordinates you have been given
    are exact coordinates.

    As your coordinates are being paseed in as double, you should instead
    be assuming that the coordinates are not precise. You then cannot
    calculate the exact slope: you can only calculate a range of slopes
    for each of the pairs, and then attempt to determine whether the two
    ranges overlap. That comparision in turn might have to be inexact.

    In short, I would suggest that you do not try to determine whether
    the lines are "exactly" parallel, and instead write your code to
    determine whether they are parallel to within a tolerance.
    You will find even this to be a challenge to get right in the case
    where the coordinate differences are either very small or very large.
    Walter Roberson, Apr 27, 2006
  5. Right. Checking whether the slopes are exactly equal is relatively
    easy, but doesn't work if the input data is inexact (as it almost
    inevitably will be). Checking whether the slopes are nearly equal is
    tempting, but it breaks down in some cases; for example, two lines
    might both be nearly vertical, and therefore nearly parallel to each
    other, but have slopes of -1.0e6 and +1.0e6.

    Mathematically, I think the best approach is to compute the *angle*
    between the lines; if the angle is close to 0, the lines are nearly
    parallel. You also need to decide what "nearly" means; determining
    whether a small difference in angle comes from roundoff error or
    indicates that the lines really aren't parallel is probably the
    toughest part of the problem. might be a good place for this kind of thing.
    (I base that purely on the name of the newsgroup; browse it and/or
    read its FAQ before posting.)
    Keith Thompson, Apr 27, 2006
  6. Is that 6 supposed to be negative?
    You could simply store rise/run as two distinct integers (or floats, I
    guess), and compare those. In the case of integers you will get an exact

    Of course, then you have problems with lowest terms; how do you tell if
    (6/3) and (2/1) are the same?
    Andrew Poelstra, Apr 27, 2006
  7. No.

    A line with a very large positive slope is nearly vertical. A line
    with a very large negative slope is also nearly vertical.

    A line with a slop of -1.0e-6 or +1.0e-6 would be nearly horizontal;
    that doesn't illustrate the point I was making because those two
    slopes are numerically close to each other. With slopes of very large
    magnitude, you can have nearly parallel lines whose slopes differ

    On the other hand, if you're really interested in whether the lines
    have similar slopes, you can ignore this. It all depends on what the
    actual requirements are, and what they're based on.
    Reducing integer fractions to lowest terms isn't difficult; Euclid
    knew how to do it.

    If you can get your raw data in a form that's not subject to rounding
    errors (multi-precision rationals, for example), you don't have to
    worry about approximate results; you can determine whether the lines
    are exactly parallel or not. The details depend strongly on the input
    data format. Without knowing anything about that, there aren't really
    any C issues.
    Keith Thompson, Apr 27, 2006
  8. lovecreatesbeauty

    Old Wolf Guest

    No. Consider a line that's almost vertical but not quite (eg.
    the side of that tall pointy thing near the white house).
    Say its "rise" is 100m and its "run" is 10mm. So its slope is
    10000. Then consider a nearby line whose rise is 1000m and
    run is 10.01mm. Its slope is 9990. This difference is 10, which
    is much larger than our tolerance of 1e-6 so the lines should
    not be considered parallel.

    But consider the same structure lying on its side. Now the
    first line has "rise" 10mm and "run" 100m so its slope is
    0.0001. The second line's slope is 0.0001001. The difference
    is 0.0000001 which is within our tolerance, so the lines are
    now parallel!

    Hence the suggestion to consider the angles of the lines,
    rather than their slope, ie. arctan(rise/run)
    Most floats are not exact.
    a/b == c/d iff ad == bc.

    If you can't multiply due to problems with integer overflow,
    then test (a/c).d == b and (a/c).c == a.
    Old Wolf, Apr 27, 2006
  9. Comparing floating point values is problematic.
    Comparing slopes to check for parallelism is even more problematic.
    Slope is undefined for lines parallel to the y axis (the axis of

    Here is the proper way to check for parallelism.

    Suppose line 1 goes through points A=(a1,a2), B=(b1,b2), and A != B.
    Suppose line 2 goes through points C=(c1,c2), D=(d1,d2), and C != D.

    Then the lines are parallel if and only if

    (b1 - a1) * (d2 - c2) - (b2 - a2) * (d1 - c1) = 0.

    This involves no divisions and works for arbitrary lines, including
    those that are parallel to the y axis.
    Rouben Rostamian, Apr 28, 2006
  10. The OP's data structure showed the coordinates to be stored as doubles.
    What is the "proper way" to test that A != B or C != D for
    pairs of doubles? cf. a recent thread that explored that even
    if you had b = a; if (a = b) that you could not be sure
    the test would succeed.

    Yes, it involves no divisions, but on the other hand it involves
    2 multiplications and 4 subtractions -- which not only results
    in precision problems, but also leads to the possibility of
    arithmetic overflow (e.g., let a1 and c2 be small and b1 and d2 be
    very large...)

    If you had
    b1 = -a1; b2 = -a2; d1 = -c1; d2 = -c2;
    then as you changed the signs of all of the components, the two should
    have exactly the same slope. Have a look, though, at what the formula
    would calculate:

    (-a1 - a1) * (-c2 - c2) - (-a2 - a2) *(-c1 - c1)

    Evalulated symbolically, that would be

    4 * a1 * c2 - 4 * a2 * c1

    but in practice it's going to be:

    (-2 * a1 + e1) * (-2 * c2 + e2) - (-2 * a2 + e3) * (-2 * c1 + e4)

    which differs by

    2 * (a2 * e4 + c1 * e3) - 2 * (a1 * e2 + c2 * e1) + e1 * e2 - e3 * e4

    Suppose we get really close -- suppose only one of the epsilons (e1)
    is 1e-15 and the others are 0. The difference would then be
    - 1/500000000000000 * c2 and if c2 were (say) 5e18 then the
    difference term would be -10000 which is clearly non-negligable.

    When you are doing your numerical analysis, keep in mind that
    (-a + -b) is not necessarily going to be the same as (- (a + b))
    because rounding can be different for negative and positive
    quantities. The rounding scheme that attempts to avoid that is
    "round to even" -- but if you "round to even" then if you are
    given a particular double P then instead of knowing that the
    original value was (P +/- epsilon), you now have to deal with
    the original value potentially being (P +/- (2 * epsilon)),
    which will change your analysis...
    Walter Roberson, Apr 28, 2006
  11. lovecreatesbeauty

    Old Wolf Guest

    See my other post on this thread. This equation is algebraically
    equivalent to subtracting the gradients.

    In the case of integer coordinates, this equation runs the
    risk of integer overflow. I gave a version that instead uses
    division and avoid overflow.

    In the case of floating point coordinates, all quantities are
    imprecise, so you cannot perform some computation and
    check if it equals zero. You must check if it is less than
    some small epsilon value. The gradient subtraction has
    the problem that an appropriate epsilon also depends on
    the gradients themself, eg. lines with angle 89.990 and
    89.991 have a gradient diffference of 1086 (this is the
    value that your above expression would give), whereas
    lines with angle 0.010 and 0.009 have a gradient
    difference of .0000165 .
    Old Wolf, Apr 28, 2006
  12. lovecreatesbeauty

    Old Wolf Guest

    Note that before doing this test you should reduce the
    fractions to their lowest terms.
    Old Wolf, Apr 28, 2006
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.