Find distance between 2 points on grid

Question

Im finding the distance between two points, given departure = [x,y] and destination = [x,y]. With x or y, one is always a float and the other an int, so its always on a line. You have to stay on the gridlines to get to the destination point, and there is no set incrementation. I havent seen any other posts on finding distance on a grid that deal with the mix of ints and floats so here I am.

This is my code:

def perfectCity(departure, destination):
    return abs(destination[0]-departure[0]) + abs(destination[1]-departure[1]) 

An example would be departure = [0.4, 1] and destination = [0.9, 3], it should equal 2.7, but I get 2.5

For example, you go from [0.4, 1] to [1, 1] to [1, 3] to [0.9, 3] for a total difference of 2.7. It's like calculating the Manhattan distance, but instead of starting and ending at lattice points, you might start and/or end half-way down a block.

Answer 1

When you look at the different combinations, it seems like the naive Manhattan distance will work, except when your path takes on a "C" shape (as given in the example). This will happen if and only if your two float points are both x-coordinates or y-coordinates and have the same integer part.

An attempt might look like:

def minimum_distance(p1, p2):

    i1, i2 = int(p1[0]), int(p2[0])

    # if both x-coordinates are floats and they have the same integer part
    if i1 != p1[0] and i2 != p2[0] and i1 == i2:

        # find the decimal parts
        d1, d2 = p1[0] - i1, p2[0] - i2

        # find the smaller "C"
        x = min(d1 + d2, (1-d1) + (1-d2))

        # add the y distance to the "C" distance
        return abs(p1[1] - p2[1]) + x

    # repeat with the "y-coordinates are floats" case
    i1, i2 = int(p1[1]), int(p2[1])
    if i1 != p1[1] and i2 != p2[1] and i1 == i2:
        d1, d2 = p1[1] - i1, p2[1] - i2
        y = min(d1 + d2, (1-d1) + (1-d2))
        return abs(p1[0] - p2[0]) + y

    # simple case, return the Manhattan distance
    return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])


print(minimum_distance([0.4, 1], [0.9, 3]))
# 2.7

Answer 2

From each house take a short-range taxicab to a corner. You have two ways of doing so. Then -- take a long-range taxicab between the resulting corners. There are 2x2 = 4 possibilities, depending on the corners traveled to. Take the min:

from math import ceil,floor

#as a helper function, vanilla taxicab:

def t(p,q):
    x,y = p
    z,w = q
    return abs(x-z)+abs(y-w)

#find the two corners closest to a point:

def corners(p):
    x,y = p
    if isinstance(x,float):
        return [(floor(x),y),(ceil(x),y)]
    else:
        return [(x,floor(y)), (x,ceil(y))]

#combine these:   

def dist(p,q):
    return min(t(p,c) + t(c,d) + t(d,q)  for c in corners(p) for d in corners(q))

For example,

>>> dist((.4,1),(.9,3))
2.7

Answer 3

It's not the mix of int and float, probably you are experiencing floating point error. floats are not exact, they are approximate, and can therefore be "off" by small amounts.

You could use Decimal objects provided by the decimal module to work accurately with floating point values. Here's an example:

>>> 1.1 + 2.2        # will produce small error
3.3000000000000003
>>> from decimal import Decimal
>>> Decimal('1.1') + Decimal('2.2')
Decimal('3.3')

The final result will still be "off", but using Decimal will help to avoid cumulative rounding errors:

>>> 3.3 - (1.1 + 2.2)
-4.440892098500626e-16
>>> Decimal(3.3) - (Decimal(1.1) + Decimal(2.2))
Decimal('-4.440892098500250464677810669E-16')
>>> Decimal('3.3') - (Decimal('1.1') + Decimal('2.2'))
Decimal('0.0')