How do Vector.Distance and Vector.normalized perform so well despite these operations typically requiring a square root operation?

Question

I've read in multiple different places that square root operations are slow and should generally be avoided within the update loop. However, I've noticed that the Distance and normalization functions on Vector2 and Vector3 perform fairly well and don't seem to cause any problems when I use them in my Update function.

Do these functions actually perform square root operations? If not, what kind of approximations are they using to achieve the same result?

Answer 1

Best Answer

Answer by HenryStrattonFW · Oct 27, 2015 at 06:22 PM

Yes, these function are doing square root operations, which is why there are alternatives like squared magnitude and DistanceSquared to get around those slower methods.

However the speed difference will likely be generally unnoticeable unless you are making a lot of calls to them each frame (and I mean a lot) typically there is no problem using the more costly methods and you wont necessarily have to optimize them unless you really start seeing performance issues and need to get every bit of performance you can back.

2 Show 1 · Share

Eno-Khaon · Oct 27, 2015 at 07:15 PM 1

Share

Adding to this:

As one example of a simple, visual way to see an immediate feedback on this type of operation, you could try something like this:

 using UnityEngine;
 using System.Collections;

 public class OperationTime: MonoBehaviour
 {
     float startTime = 0;
     float endTime = 0;
     int i;
     Vector3 startVector = new Vector3(-2.738f, 5.49985f, 2.070492f);
     Vector3 endVector = new Vector3(7.32086f, 15.38201f, -9.11523f);
     Vector3 normalizedResult;
     float distanceResult;
 
     void Update()
     {
         // normalize 10,000,000 vectors
         if(Input.GetKeyDown(KeyCode.A))
         {
             startTime = Time.realtimeSinceStartup;
             for(i = 0; i < 10000000; i++)
             {
                 normalizedResult = (startVector - endVector).normalized;
             }
             endTime = Time.realtimeSinceStartup;
             Debug.Log("normalize vector:\t\t" + (endTime - startTime));
         }
         // calculate 10,000,000 vector magnitudes
         if(Input.GetKeyDown(KeyCode.S))
         {
             startTime = Time.realtimeSinceStartup;
             for(i = 0; i < 10000000; i++)
             {
                 distanceResult = (startVector - endVector).magnitude;
             }
             endTime = Time.realtimeSinceStartup;
             Debug.Log("magnitude:\t\t" + (endTime - startTime));
         }
         // calculate 10,000,000 vector magnitudes (alternate)
         if(Input.GetKeyDown(KeyCode.D))
         {
             startTime = Time.realtimeSinceStartup;
             for(i = 0; i < 10000000; i++)
             {
                 distanceResult = Vector3.Distance(startVector, endVector);
             }
             endTime = Time.realtimeSinceStartup;
             Debug.Log("magnitude (Vector3.Distance):\t" + (endTime - startTime));
         }
         // calculate 10,000,000 vector square magnitudes
         if(Input.GetKeyDown(KeyCode.F))
         {
             startTime = Time.realtimeSinceStartup;
             for(i = 0; i < 10000000; i++)
             {
                 distanceResult = (startVector - endVector).sqrMagnitude;
             }
             endTime = Time.realtimeSinceStartup;
             Debug.Log("sqrMagnitude:\t\t" + (endTime - startTime));
         }
     }
 }

You might be surprised at how quickly and slowly some things are processed.

Answer 2

Answer by starikcetin · Oct 27, 2015 at 08:21 PM

These kind of suggestions are for developers whose aim is to "maximize" the performance. That differences won't even be visible to human eyes.

0 Show 2 · Share

Eno-Khaon · Oct 27, 2015 at 08:36 PM 1

Share

True. In the grand scheme of things, it likely won't make a big difference.

However, that doesn't automatically discredit their use.

While it certainly doesn't apply to all games, there's no harm in finding ways of improving what you have. For example, if you take a look at tag comparison vs. layer comparison,

 if(gameObject.tag == "ThisTag")

is slower than

 if(gameObject.CompareTag("ThisTag"))

is much, much slower than

 if(gameObject.layer == thisLayer)

This is a question and answer combination which can lead to various optimizations and, while some might argue that there's no need to optimize in the beginning, the first step to optimization is to know what you can do and when.

Just because something is slower, that doesn't mean it needs to be your first choice.

starikcetin Eno-Khaon · Oct 27, 2015 at 08:41 PM 0

Share

I haven't mentioned that they are useless, I respect the suggestion. But for the early stages of development, people shouldn't force theirselves to maximize performance, that's a thing they get around later imho.

How do Vector.Distance and Vector.normalized perform so well despite these operations typically requiring a square root operation?

2 Replies

Your answer

Welcome to Unity Answers

Follow this Question

Related Questions