In order to compare two vectors – to determine whether both vectors point to the same place, we need to compare the coordinates of both vectors and if they are equal, then the vectors are also equal. However, the coordinates of the vectors are specified by float values, the comparison of which for equality, due to the peculiarities of storing this type in computer memory, is never accurate.
.blend file on Patreon
Let’s look at this with an example. Add two objects to the scene, each of one edge. This edge will denote a vector in the 3D scene space. Name the objects “V0” and “V1” and place them in the scene in exactly the same place – from the beginning of the scene (0, 0, 0) to any other point. The easiest way is first to create one object, and then make a copy of it by pressing shift + d.
Now we can get the coordinates of the vectors formed by our objects:
|
1 2 3 4 5 6 7 8 |
v0 = bpy.data.objects['V0'].data.vertices[1].co v1 = bpy.data.objects['V1'].data.vertices[1].co print('v0 x:', v0.x, 'y: ', v0.y, 'z: ', v0.z) print('v1 x:', v1.x, 'y: ', v1.y, 'z: ', v1.z) # v0 x: 1.6818300485610962 y: -0.2943689227104187 z: 3.1925301551818848 # v1 x: 1.6818300485610962 y: -0.2943689227104187 z: 3.1925301551818848 |
As we can see, the coordinates of the vectors are completely equal.
Looking at this, it seems that we can write a simple function that will compare the corresponding coordinates of two vectors and return the result of the comparison for all three coordinates.
Something like this:
|
1 2 3 4 |
def vector_equal(v0, v1): if v0.x == v1.x and v0.y == v1.y and v0.z == v1.z: return True return False |
And if we try to test this function on our two vectors, we will get the correct answer.
|
1 2 3 |
print('are vectors equal:', vector_equal(v0, v1)) # are vectors equal: True |
However, let’s not rejoice too soon.
We know from math course that the value will not change if we perform any mathematical operation on it, and then perform the opposite operation. For example, add one, and then subtract one. Or divide by ten, and then multiply by ten.
Let’s experiment by dividing the X coordinate of our vector “V1” by three, and then multiply it back by three.
|
1 2 |
v1.x /= 3 v1.x *= 3 |
The final value should not differ from the original, but if we print the vector coordinates again, we will see some changes.
|
1 2 3 4 5 |
print('v0 x:', v0.x, 'y: ', v0.y, 'z: ', v0.z) print('v1 x:', v1.x, 'y: ', v1.y, 'z: ', v1.z) # v0 x: 1.6818300485610962 y: -0.2943689227104187 z: 3.1925301551818848 # v1 x: 1.6818299293518066 y: -0.2943689227104187 z: 3.1925301551818848 |
Starting from about the fifth decimal place, the value of the X coordinate now differs from the same value of the second vector, which we did not touch.
There are no contradictions with mathematics here, we just need to remember that computer memory is designed in such a way that it cannot store floating-point numbers with absolute precision.
And now, if we try to compare vectors again using the function we wrote above, we will get the wrong result.
|
1 2 3 |
print('are vectors equal:', vector_equal(v0, v1)) # are vectors equal: False |
How then do we compare vectors?
To get more predictable results when comparing floating-point numbers, they are usually not compared for absolute equality, but rather checked to see if one number differs from the other by more than a given delta – usually a small number with three to five zeros after the decimal point.
The simplest equation for such a comparison looks like this:
|
1 |
abs(variable1 - variable2) < delta |
and its more applicable analogue:
|
1 |
abs(variable1 - variable2) < delta * max(abs(variable1), abs(variable2)) |
This equation version allows us to conveniently spread the comparison delta if two very large numbers are compared. At the same time, such a formula does not work well if two numbers close to zero are compared.
Therefore, the most commonly used equation is one that takes into account two deltas: relative “rel_tol” and absolute “abs_tol”. In this case, the formula looks like this:
|
1 |
abs(variable1 - variable2) < max(rel_tol * max(abs(variable1), abs(variable2)), abs_tol) |
Let’s return to our vectors and try to apply this formula in the function of their comparison.
|
1 2 3 4 5 6 |
def vector_close(v0, v1, rel_tol=1e-09, abs_tol=0.001): if abs(v0.x - v1.x) < max(rel_tol * max(abs(v0.x), abs(v1.x)), abs_tol) \ and abs(v0.y - v1.y) < max(rel_tol * max(abs(v0.y), abs(v1.y)), abs_tol) \ and abs(v0.z - v1.z) < max(rel_tol * max(abs(v0.z), abs(v1.z)), abs_tol): return True return False |
And use it for comparison of our vectors with different delta.
|
1 2 |
print('are vectors close: ', vector_close(v0, v1, abs_tol=0.0000001)) print('are vectors close: ', vector_close(v0, v1, abs_tol=0.00001)) |
While our vectors are absolutely identical, we get the following result:
|
1 2 |
# are vectors close: True # are vectors close: True |
And after the noise appearing caused by mathematical operations:
|
1 2 |
# are vectors close: False # are vectors close: True |
So, comparing two vectors with given the delta, we can assume that the vectors are the same within the specified measurement error.