Optimize planner with precalculation, etc.

[thinkyhead]

Assuming all steps-per-mm are set to equal values on a DELTA (the usual case) we can reduce overhead by two float divisions and three float squarings. The key is to first calculate the distance moved sqrt(sq(dx) + sq(dy) + sq(dz)) in steps, and only afterward divide by steps_per_mm.

This PR applies this approach to optimize the planner for DELTA, and also generally fixes and optimizes the planner with the following changes:

• Add Planner::steps_to_mm[4] to contain 1.0 / axis_steps_per_mm[].
• Add Planner::refresh_positioning() to handle any change of axis_steps_per_mm:
  • Updates steps_to_mm, planner.position, and stepper.count
• Call planner.refresh_positioning() in Config_Postprocess() and gcode_M92().
• Call planner.refresh_positioning() for menu items that alter axis_steps_per_mm

Other math optimizations:

• Multiply by 0.5, 0.125, etc., rather than divide by 2.0, 8.0, etc.

@Wurstnase has also suggested using the inverse-sqrt from the Quake source code. I'm investigating that next.

float inverse_sqrt(float number) {
  long i;
  float x2, y;
  const float threehalfs = 1.5f;

  x2 = number * 0.5F;
  y  = number;
  i  = * ( long * ) &y;                     // evil floating point bit level hacking
  i  = 0x5f3759df - ( i >> 1 );             // what the fuck? 
  y  = * ( float * ) &i;
  y  *= ( threehalfs - ( x2 * y * y ) );    // 1st iteration
  // y *= ( threehalfs - ( x2 * y * y ) );  // 2nd iteration, this can be removed

  return y;
}

[Blue-Marlin]

• 0.01 ?

[Wurstnase]

You don't need to shift 32, 512 or similar. The compiler will do this for you. This will not save anything.