Distance Between Points

The Converse of the Pythagorean Theorem

If a, b , and c are the lengths of the three sides of a triangle, and a ² + b ² = c ² , the triangle is a right triangle with a hypotenuse of length c .

The Distance Formula in 2D

where P ₁ ( x ₁ , y ₁ ) and P ₂ ( x ₂ , y ₂ ) are points on the line.

The following function takes in two arrays of floats, each size 2, which represent points in 2D space and returns the distance between them. Notice the use of the sqrt() function that exists in the <cmath> header file and returns the square root of whatever number is passed into it. Also note the use of the pow() function which takes in two parameters. It returns the first parameter raised to the power of the second. While the pow function is quite useful, it is a bit slower than simply multiplying the numbers manually in the code. For instance, pow(x, 2) is not as fast as x * x . However, if using a Microsoft compiler, using the #pragma intrinsic command in the preprocessor section of your code will greatly increase the speed of most math function calls:

#pragma intrinsic(sqrt, pow)

This allows most math function calls to be sent directly to the math co-processor rather than being sent to the function stack. (For more information on the intrinsic command, do a search for intrinsic in your MSDN library.) Also notice that we are type-casting our answer to a float before it is returned. This is to avoid a truncation compiler warning due to possible loss of information when changing from a double to a float. This can also be avoided by using the less common sqrtf() and powf() which take input and return output as floats rather than doubles.

// purpose: to calculate the distance between two points

// input: P1- an array of 2 floats representing point 1

//        P2- an array of 2 floats representing point 2

// output: the distance between the two points

float distance2D(float *P1, float *P2)

{

     // Calculate our distance and return it

     return (float)sqrt(pow(P2[0]  P1[0], 2) + pow(P2[1]

P1[1], 2);

}

The Distance Formula in 3D

where P ₁ ( x ₁ , y ₁ , z ₁ ) and P ₂ ( x ₂ , y ₂ , z ₂ ) are points on the line.

The Midpoint Formula in 2D

is the midpoint between P ₁ ( x ₁ , y ₁ ) and P ₂ ( x ₂ , y ₂ ).

The following function takes two points, P1 and P2, as input and returns the midpoint. Notice in this function that we are using the new keyword to allocate memory to our temp variable. Make sure to clean up this memory when it is no longer needed by using the delete keyword. Also remember to use brackets when freeing the memory because we are using brackets to create the memory:

delete [] temp;



// purpose: calculate the midpoint of a line segment

// input: P1- an array of 2 floats representing point 1

//        P2- an array of 2 floats representing point 2

// output: the midpoint between the two points

float *find2DMidPoint(float *P1, float *P2)

{

    // Allocate enough memory to our pointer

float *temp = new float[2];

    // Calculate our midpoint

    temp[0] = (P1[0] + P2[0]) / 2.0f;

    temp[1] = (P1[1] + P2[1]) / 2.0f;

    // Return our answer

    return temp;

}

The Midpoint Formula in 3D

is the midpoint between P ₁ ( x ₁ , y ₁ , z ₁ ) and P ₂ ( x ₂ , y ₂ , z ₂ ).

Our 3D midpoint function in code is not much different from our 2D function, differing only in the addition of a third point. Once again, be sure to use delete to clean up the memory that is allocated before the program ends:

// purpose: calculate the midpoint of a line segment in 3D

// input: P1- an array of 3 floats representing point 1

//        P2- an array of 3 floats representing point 2

// output: the midpoint between the two points

float *find3DMidPoint(float *P1, float *P2)

{

    // Allocate enough memory to our pointer

float *temp = new float[3];

    // Calculate our midpoint

    temp[0] = (P1[0] + P2[0]) / 2.0f;

    temp[1] = (P1[1] + P2[1]) / 2.0f;

    temp[2] = (P1[2] + P2[2]) / 2.0f;

    // Return our answer

    return temp;

}