title: What is faster on division? doubles / floats / UInt32 / UInt64 ? in C++/C
body: <p>I did some speed testing to figure out what is the fastest, when doing multiplication or division on numbers. I had to really work hard to defeat the optimiser. I got nonsensical results such as a massive loop operating in 2 microseconds, or that multiplication was the same speed as division (if only that were true).</p>
  
  <p>After I finally worked hard enough to defeat enough of the compiler optimisations, while still letting it optimise for speed, I got these speed results. They maybe of interest to someone else?</p>
  
  <p>If my test is STILL FLAWED, let me know, but be kind seeing as I just spend two hours writing this crap :P</p>
  
  <pre><code>64 time: 3826718 us
  32 time: 2476484 us
  D(mul) time: 936524 us
  D(div) time: 3614857 us
  S time: 1506020 us
  </code></pre>
  
  <p>"Multiplying to divide" using doubles seems the fastest way to do a division, followed by integer division. I did not test the accuracy of division. Could it be that "proper division" is more accurate? I have no desire to find out after these speed test results as I'll just be using integer division on a base 10 constant and letting my compiler optimise it for me ;) (and not defeating it's optimisations either).</p>
  
  <p>Here's the code I used to get the results:</p>
  
  <pre><code>#include &lt;iostream&gt;
  
  int Run(int bla, int div, int add, int minus) {
      // these parameters are to force the compiler to not be able to optimise away the
      // multiplications and divides :)
      long LoopMax = 100000000;
  
      uint32_t Origbla32 = 1000000000;
      long i = 0;
  
      uint32_t bla32 = Origbla32;
      uint32_t div32 = div;
      clock_t Time32 = clock();
      for (i = 0; i &lt; LoopMax; i++) {
          div32 += add;
          div32 -= minus;
          bla32 = bla32 / div32;
          bla32 += bla;
          bla32 = bla32 * div32;
      }
      Time32 = clock() - Time32;
  
      uint64_t bla64 = bla32;
      clock_t Time64 = clock();
      uint64_t div64 = div;
      for (long i = 0; i &lt; LoopMax; i++) {
          div64 += add;
          div64 -= minus;
          bla64 = bla64 / div64;
          bla64 += bla;
          bla64 = bla64 * div64;
      }
      Time64 = clock() - Time64;
  
      double blaDMul = Origbla32;
      double multodiv = 1.0 / (double)div;
      double multomul = div;
      clock_t TimeDMul = clock();
      for (i = 0; i &lt; LoopMax; i++) {
          multodiv += add;
          multomul -= minus;
          blaDMul = blaDMul * multodiv;
          blaDMul += bla;
          blaDMul = blaDMul * multomul;
      }
      TimeDMul = clock() - TimeDMul;
  
      double blaDDiv = Origbla32;
      clock_t TimeDDiv = clock();
      for (i = 0; i &lt; LoopMax; i++) {
          multodiv += add;
          multomul -= minus;
          blaDDiv = blaDDiv / multomul;
          blaDDiv += bla;
          blaDDiv = blaDDiv / multodiv;
      }
      TimeDDiv = clock() - TimeDDiv;
  
      float blaS = Origbla32;
      float divS = div;
      clock_t TimeS = clock();
      for (i = 0; i &lt; LoopMax; i++) {
          divS += add;
          divS -= minus;
          blaS = blaS / divS;
          blaS += bla;
          blaS = blaS * divS;
      }
      TimeS = clock() - TimeS;
  
      printf("64 time: %i us  (%i)\n", (int)Time64, (int)bla64);
      printf("32 time: %i us  (%i)\n", (int)Time32, bla32);
  
      printf("D(mul) time: %i us  (%f)\n", (int)TimeDMul, blaDMul);
      printf("D(div) time: %i us  (%f)\n", (int)TimeDDiv, blaDDiv);
      printf("S time: %i us  (%f)\n", (int)TimeS, blaS);
  
      return 0;
  }
  
  int main(int argc, char* const argv[]) {
      Run(0, 10, 0, 0); // adds and minuses 0 so it doesn't affect the math, only kills the opts
      return 0;
  }
  </code></pre>