(sqrt(2 * acceleration * distance + velocity * velocity) - velocity) / acceleration

Percentage Accurate: 55.5% → 80.8%
Time: 6.5s
Alternatives: 9
Speedup: 1.9×

Specification

?
\[\left(\left(-100000 \leq acceleration \land acceleration \leq 100000\right) \land \left(-0.0001 \leq distance \land distance \leq 0.0001\right)\right) \land \left(-1000 \leq velocity \land velocity \leq 1000\right)\]
\[\begin{array}{l} \\ \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \end{array} \]
(FPCore (acceleration distance velocity)
 :precision binary64
 (/
  (-
   (sqrt (+ (* (* 2.0 acceleration) distance) (* velocity velocity)))
   velocity)
  acceleration))
double code(double acceleration, double distance, double velocity) {
	return (sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
}

real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    code = (sqrt((((2.0d0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration
end function

public static double code(double acceleration, double distance, double velocity) {
	return (Math.sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
}

def code(acceleration, distance, velocity):
	return (math.sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration

function code(acceleration, distance, velocity)
	return Float64(Float64(sqrt(Float64(Float64(Float64(2.0 * acceleration) * distance) + Float64(velocity * velocity))) - velocity) / acceleration)
end

function tmp = code(acceleration, distance, velocity)
	tmp = (sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
end

code[acceleration_, distance_, velocity_] := N[(N[(N[Sqrt[N[(N[(N[(2.0 * acceleration), $MachinePrecision] * distance), $MachinePrecision] + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision]

\begin{array}{l}

\\
\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}
\end{array}

Sampling outcomes in binary64 precision:

Local Percentage Accuracy vs ?

The average percentage accuracy by input value. Horizontal axis shows value of an input variable; the variable is choosen in the title. Vertical axis is accuracy; higher is better. Red represent the original program, while blue represents Herbie's suggestion. These can be toggled with buttons below the plot. The line is an average while dots represent individual samples.

Accuracy vs Speed?

Herbie found 9 alternatives:

AlternativeAccuracySpeedup
The accuracy (vertical axis) and speed (horizontal axis) of each alternatives. Up and to the right is better. The red square shows the initial program, and each blue circle shows an alternative.The line shows the best available speed-accuracy tradeoffs.

Initial Program: 55.5% accurate, 1.0× speedup?

\[\begin{array}{l} \\ \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \end{array} \]
(FPCore (acceleration distance velocity)
 :precision binary64
 (/
  (-
   (sqrt (+ (* (* 2.0 acceleration) distance) (* velocity velocity)))
   velocity)
  acceleration))
double code(double acceleration, double distance, double velocity) {
	return (sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
}

real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    code = (sqrt((((2.0d0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration
end function

public static double code(double acceleration, double distance, double velocity) {
	return (Math.sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
}

def code(acceleration, distance, velocity):
	return (math.sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration

function code(acceleration, distance, velocity)
	return Float64(Float64(sqrt(Float64(Float64(Float64(2.0 * acceleration) * distance) + Float64(velocity * velocity))) - velocity) / acceleration)
end

function tmp = code(acceleration, distance, velocity)
	tmp = (sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
end

code[acceleration_, distance_, velocity_] := N[(N[(N[Sqrt[N[(N[(N[(2.0 * acceleration), $MachinePrecision] * distance), $MachinePrecision] + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision]

\begin{array}{l}

\\
\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}
\end{array}

Alternative 1: 80.8% accurate, 0.3× speedup?

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}\\ \mathbf{if}\;t\_0 \leq -5 \cdot 10^{-127} \lor \neg \left(t\_0 \leq 5 \cdot 10^{-150}\right):\\ \;\;\;\;\frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \left(acceleration \cdot 2\right)\right)}}{acceleration} - \frac{velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \end{array} \]
(FPCore (acceleration distance velocity)
 :precision binary64
 (let* ((t_0
         (/
          (-
           (sqrt (+ (* (* 2.0 acceleration) distance) (* velocity velocity)))
           velocity)
          acceleration)))
   (if (or (<= t_0 -5e-127) (not (<= t_0 5e-150)))
     (-
      (/
       (sqrt (fma velocity velocity (* distance (* acceleration 2.0))))
       acceleration)
      (/ velocity acceleration))
     (/ distance velocity))))
double code(double acceleration, double distance, double velocity) {
	double t_0 = (sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
	double tmp;
	if ((t_0 <= -5e-127) || !(t_0 <= 5e-150)) {
		tmp = (sqrt(fma(velocity, velocity, (distance * (acceleration * 2.0)))) / acceleration) - (velocity / acceleration);
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

function code(acceleration, distance, velocity)
	t_0 = Float64(Float64(sqrt(Float64(Float64(Float64(2.0 * acceleration) * distance) + Float64(velocity * velocity))) - velocity) / acceleration)
	tmp = 0.0
	if ((t_0 <= -5e-127) || !(t_0 <= 5e-150))
		tmp = Float64(Float64(sqrt(fma(velocity, velocity, Float64(distance * Float64(acceleration * 2.0)))) / acceleration) - Float64(velocity / acceleration));
	else
		tmp = Float64(distance / velocity);
	end
	return tmp
end

code[acceleration_, distance_, velocity_] := Block[{t$95$0 = N[(N[(N[Sqrt[N[(N[(N[(2.0 * acceleration), $MachinePrecision] * distance), $MachinePrecision] + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision]}, If[Or[LessEqual[t$95$0, -5e-127], N[Not[LessEqual[t$95$0, 5e-150]], $MachinePrecision]], N[(N[(N[Sqrt[N[(velocity * velocity + N[(distance * N[(acceleration * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / acceleration), $MachinePrecision] - N[(velocity / acceleration), $MachinePrecision]), $MachinePrecision], N[(distance / velocity), $MachinePrecision]]]

\begin{array}{l}

\\
\begin{array}{l}
t_0 := \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{-127} \lor \neg \left(t\_0 \leq 5 \cdot 10^{-150}\right):\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \left(acceleration \cdot 2\right)\right)}}{acceleration} - \frac{velocity}{acceleration}\\

\mathbf{else}:\\
\;\;\;\;\frac{distance}{velocity}\\


\end{array}
\end{array}
Derivation
  1. Split input into 2 regimes

  2. if (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration) < -4.9999999999999997e-127 or 4.9999999999999999e-150 < (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration)

    1. Initial program 75.5%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing
    3. Step-by-step derivation

      1. lift-/.f64N/A

        \[\leadsto \color{blue}{\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}} \]

      2. lift--.f64N/A

        \[\leadsto \frac{\color{blue}{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}}{acceleration} \]

      3. div-subN/A

        \[\leadsto \color{blue}{\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity}}{acceleration} - \frac{velocity}{acceleration}} \]

      4. lower--.f64N/A

        \[\leadsto \color{blue}{\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity}}{acceleration} - \frac{velocity}{acceleration}} \]

      5. lower-/.f64N/A

        \[\leadsto \color{blue}{\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity}}{acceleration}} - \frac{velocity}{acceleration} \]

      6. lift-+.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity}}}{acceleration} - \frac{velocity}{acceleration} \]

      7. +-commutativeN/A

        \[\leadsto \frac{\sqrt{\color{blue}{velocity \cdot velocity + \left(2 \cdot acceleration\right) \cdot distance}}}{acceleration} - \frac{velocity}{acceleration} \]

      8. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{velocity \cdot velocity} + \left(2 \cdot acceleration\right) \cdot distance}}{acceleration} - \frac{velocity}{acceleration} \]

      9. lower-fma.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\mathsf{fma}\left(velocity, velocity, \left(2 \cdot acceleration\right) \cdot distance\right)}}}{acceleration} - \frac{velocity}{acceleration} \]

      10. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(velocity, velocity, \color{blue}{\left(2 \cdot acceleration\right) \cdot distance}\right)}}{acceleration} - \frac{velocity}{acceleration} \]

      11. *-commutativeN/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(velocity, velocity, \color{blue}{distance \cdot \left(2 \cdot acceleration\right)}\right)}}{acceleration} - \frac{velocity}{acceleration} \]

      12. lower-*.f64N/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(velocity, velocity, \color{blue}{distance \cdot \left(2 \cdot acceleration\right)}\right)}}{acceleration} - \frac{velocity}{acceleration} \]

      13. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \color{blue}{\left(2 \cdot acceleration\right)}\right)}}{acceleration} - \frac{velocity}{acceleration} \]

      14. *-commutativeN/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \color{blue}{\left(acceleration \cdot 2\right)}\right)}}{acceleration} - \frac{velocity}{acceleration} \]

      15. lower-*.f64N/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \color{blue}{\left(acceleration \cdot 2\right)}\right)}}{acceleration} - \frac{velocity}{acceleration} \]

      16. lower-/.f6475.6

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \left(acceleration \cdot 2\right)\right)}}{acceleration} - \color{blue}{\frac{velocity}{acceleration}} \]

    4. Applied rewrites75.6%

      \[\leadsto \color{blue}{\frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \left(acceleration \cdot 2\right)\right)}}{acceleration} - \frac{velocity}{acceleration}} \]

    if -4.9999999999999997e-127 < (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration) < 4.9999999999999999e-150

    1. Initial program 4.3%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing

    3. Taylor expanded in acceleration around 0

      \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
    4. Step-by-step derivation

      1. lower-/.f6491.9

        \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

    5. Applied rewrites91.9%

      \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
  3. Recombined 2 regimes into one program.

  4. Final simplification80.1%

    \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \leq -5 \cdot 10^{-127} \lor \neg \left(\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \leq 5 \cdot 10^{-150}\right):\\ \;\;\;\;\frac{\sqrt{\mathsf{fma}\left(velocity, velocity, distance \cdot \left(acceleration \cdot 2\right)\right)}}{acceleration} - \frac{velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \]
  5. Add Preprocessing

Alternative 2: 80.8% accurate, 0.3× speedup?

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}\\ \mathbf{if}\;t\_0 \leq -5 \cdot 10^{-127} \lor \neg \left(t\_0 \leq 5 \cdot 10^{-150}\right):\\ \;\;\;\;\frac{\sqrt{\mathsf{fma}\left(distance \cdot 2, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \end{array} \]
(FPCore (acceleration distance velocity)
 :precision binary64
 (let* ((t_0
         (/
          (-
           (sqrt (+ (* (* 2.0 acceleration) distance) (* velocity velocity)))
           velocity)
          acceleration)))
   (if (or (<= t_0 -5e-127) (not (<= t_0 5e-150)))
     (/
      (-
       (sqrt (fma (* distance 2.0) acceleration (* velocity velocity)))
       velocity)
      acceleration)
     (/ distance velocity))))
double code(double acceleration, double distance, double velocity) {
	double t_0 = (sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
	double tmp;
	if ((t_0 <= -5e-127) || !(t_0 <= 5e-150)) {
		tmp = (sqrt(fma((distance * 2.0), acceleration, (velocity * velocity))) - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

function code(acceleration, distance, velocity)
	t_0 = Float64(Float64(sqrt(Float64(Float64(Float64(2.0 * acceleration) * distance) + Float64(velocity * velocity))) - velocity) / acceleration)
	tmp = 0.0
	if ((t_0 <= -5e-127) || !(t_0 <= 5e-150))
		tmp = Float64(Float64(sqrt(fma(Float64(distance * 2.0), acceleration, Float64(velocity * velocity))) - velocity) / acceleration);
	else
		tmp = Float64(distance / velocity);
	end
	return tmp
end

code[acceleration_, distance_, velocity_] := Block[{t$95$0 = N[(N[(N[Sqrt[N[(N[(N[(2.0 * acceleration), $MachinePrecision] * distance), $MachinePrecision] + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision]}, If[Or[LessEqual[t$95$0, -5e-127], N[Not[LessEqual[t$95$0, 5e-150]], $MachinePrecision]], N[(N[(N[Sqrt[N[(N[(distance * 2.0), $MachinePrecision] * acceleration + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision], N[(distance / velocity), $MachinePrecision]]]

\begin{array}{l}

\\
\begin{array}{l}
t_0 := \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{-127} \lor \neg \left(t\_0 \leq 5 \cdot 10^{-150}\right):\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(distance \cdot 2, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration}\\

\mathbf{else}:\\
\;\;\;\;\frac{distance}{velocity}\\


\end{array}
\end{array}
Derivation
  1. Split input into 2 regimes

  2. if (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration) < -4.9999999999999997e-127 or 4.9999999999999999e-150 < (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration)

    1. Initial program 75.5%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing
    3. Step-by-step derivation

      1. lift-+.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity}} - velocity}{acceleration} \]

      2. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right) \cdot distance} + velocity \cdot velocity} - velocity}{acceleration} \]

      3. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right)} \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]

      4. associate-*l*N/A

        \[\leadsto \frac{\sqrt{\color{blue}{2 \cdot \left(acceleration \cdot distance\right)} + velocity \cdot velocity} - velocity}{acceleration} \]

      5. *-commutativeN/A

        \[\leadsto \frac{\sqrt{2 \cdot \color{blue}{\left(distance \cdot acceleration\right)} + velocity \cdot velocity} - velocity}{acceleration} \]

      6. associate-*r*N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot distance\right) \cdot acceleration} + velocity \cdot velocity} - velocity}{acceleration} \]

      7. lower-fma.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\mathsf{fma}\left(2 \cdot distance, acceleration, velocity \cdot velocity\right)}} - velocity}{acceleration} \]

      8. *-commutativeN/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(\color{blue}{distance \cdot 2}, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration} \]

      9. lower-*.f6475.5

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(\color{blue}{distance \cdot 2}, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration} \]

    4. Applied rewrites75.5%

      \[\leadsto \frac{\sqrt{\color{blue}{\mathsf{fma}\left(distance \cdot 2, acceleration, velocity \cdot velocity\right)}} - velocity}{acceleration} \]

    if -4.9999999999999997e-127 < (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration) < 4.9999999999999999e-150

    1. Initial program 4.3%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing

    3. Taylor expanded in acceleration around 0

      \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
    4. Step-by-step derivation

      1. lower-/.f6491.9

        \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

    5. Applied rewrites91.9%

      \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
  3. Recombined 2 regimes into one program.

  4. Final simplification80.1%

    \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \leq -5 \cdot 10^{-127} \lor \neg \left(\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \leq 5 \cdot 10^{-150}\right):\\ \;\;\;\;\frac{\sqrt{\mathsf{fma}\left(distance \cdot 2, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \]
  5. Add Preprocessing

Alternative 3: 80.8% accurate, 0.3× speedup?

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}\\ \mathbf{if}\;t\_0 \leq -5 \cdot 10^{-127}:\\ \;\;\;\;\frac{\sqrt{\mathsf{fma}\left(distance \cdot 2, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration}\\ \mathbf{elif}\;t\_0 \leq 5 \cdot 10^{-150}:\\ \;\;\;\;\frac{distance}{velocity}\\ \mathbf{else}:\\ \;\;\;\;\frac{\sqrt{\mathsf{fma}\left(distance \cdot acceleration, 2, velocity \cdot velocity\right)} - velocity}{acceleration}\\ \end{array} \end{array} \]
(FPCore (acceleration distance velocity)
 :precision binary64
 (let* ((t_0
         (/
          (-
           (sqrt (+ (* (* 2.0 acceleration) distance) (* velocity velocity)))
           velocity)
          acceleration)))
   (if (<= t_0 -5e-127)
     (/
      (-
       (sqrt (fma (* distance 2.0) acceleration (* velocity velocity)))
       velocity)
      acceleration)
     (if (<= t_0 5e-150)
       (/ distance velocity)
       (/
        (-
         (sqrt (fma (* distance acceleration) 2.0 (* velocity velocity)))
         velocity)
        acceleration)))))
double code(double acceleration, double distance, double velocity) {
	double t_0 = (sqrt((((2.0 * acceleration) * distance) + (velocity * velocity))) - velocity) / acceleration;
	double tmp;
	if (t_0 <= -5e-127) {
		tmp = (sqrt(fma((distance * 2.0), acceleration, (velocity * velocity))) - velocity) / acceleration;
	} else if (t_0 <= 5e-150) {
		tmp = distance / velocity;
	} else {
		tmp = (sqrt(fma((distance * acceleration), 2.0, (velocity * velocity))) - velocity) / acceleration;
	}
	return tmp;
}

function code(acceleration, distance, velocity)
	t_0 = Float64(Float64(sqrt(Float64(Float64(Float64(2.0 * acceleration) * distance) + Float64(velocity * velocity))) - velocity) / acceleration)
	tmp = 0.0
	if (t_0 <= -5e-127)
		tmp = Float64(Float64(sqrt(fma(Float64(distance * 2.0), acceleration, Float64(velocity * velocity))) - velocity) / acceleration);
	elseif (t_0 <= 5e-150)
		tmp = Float64(distance / velocity);
	else
		tmp = Float64(Float64(sqrt(fma(Float64(distance * acceleration), 2.0, Float64(velocity * velocity))) - velocity) / acceleration);
	end
	return tmp
end

code[acceleration_, distance_, velocity_] := Block[{t$95$0 = N[(N[(N[Sqrt[N[(N[(N[(2.0 * acceleration), $MachinePrecision] * distance), $MachinePrecision] + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision]}, If[LessEqual[t$95$0, -5e-127], N[(N[(N[Sqrt[N[(N[(distance * 2.0), $MachinePrecision] * acceleration + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision], If[LessEqual[t$95$0, 5e-150], N[(distance / velocity), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(distance * acceleration), $MachinePrecision] * 2.0 + N[(velocity * velocity), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision]]]]

\begin{array}{l}

\\
\begin{array}{l}
t_0 := \frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration}\\
\mathbf{if}\;t\_0 \leq -5 \cdot 10^{-127}:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(distance \cdot 2, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration}\\

\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{-150}:\\
\;\;\;\;\frac{distance}{velocity}\\

\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(distance \cdot acceleration, 2, velocity \cdot velocity\right)} - velocity}{acceleration}\\


\end{array}
\end{array}
Derivation
  1. Split input into 3 regimes

  2. if (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration) < -4.9999999999999997e-127

    1. Initial program 77.8%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing
    3. Step-by-step derivation

      1. lift-+.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity}} - velocity}{acceleration} \]

      2. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right) \cdot distance} + velocity \cdot velocity} - velocity}{acceleration} \]

      3. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right)} \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]

      4. associate-*l*N/A

        \[\leadsto \frac{\sqrt{\color{blue}{2 \cdot \left(acceleration \cdot distance\right)} + velocity \cdot velocity} - velocity}{acceleration} \]

      5. *-commutativeN/A

        \[\leadsto \frac{\sqrt{2 \cdot \color{blue}{\left(distance \cdot acceleration\right)} + velocity \cdot velocity} - velocity}{acceleration} \]

      6. associate-*r*N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot distance\right) \cdot acceleration} + velocity \cdot velocity} - velocity}{acceleration} \]

      7. lower-fma.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\mathsf{fma}\left(2 \cdot distance, acceleration, velocity \cdot velocity\right)}} - velocity}{acceleration} \]

      8. *-commutativeN/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(\color{blue}{distance \cdot 2}, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration} \]

      9. lower-*.f6477.8

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(\color{blue}{distance \cdot 2}, acceleration, velocity \cdot velocity\right)} - velocity}{acceleration} \]

    4. Applied rewrites77.8%

      \[\leadsto \frac{\sqrt{\color{blue}{\mathsf{fma}\left(distance \cdot 2, acceleration, velocity \cdot velocity\right)}} - velocity}{acceleration} \]

    if -4.9999999999999997e-127 < (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration) < 4.9999999999999999e-150

    1. Initial program 4.3%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing

    3. Taylor expanded in acceleration around 0

      \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
    4. Step-by-step derivation

      1. lower-/.f6491.9

        \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

    5. Applied rewrites91.9%

      \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

    if 4.9999999999999999e-150 < (/.f64 (-.f64 (sqrt.f64 (+.f64 (*.f64 (*.f64 #s(literal 2 binary64) acceleration) distance) (*.f64 velocity velocity))) velocity) acceleration)

    1. Initial program 73.5%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing
    3. Step-by-step derivation

      1. lift-+.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity}} - velocity}{acceleration} \]

      2. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right) \cdot distance} + velocity \cdot velocity} - velocity}{acceleration} \]

      3. lift-*.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(2 \cdot acceleration\right)} \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]

      4. associate-*l*N/A

        \[\leadsto \frac{\sqrt{\color{blue}{2 \cdot \left(acceleration \cdot distance\right)} + velocity \cdot velocity} - velocity}{acceleration} \]

      5. *-commutativeN/A

        \[\leadsto \frac{\sqrt{\color{blue}{\left(acceleration \cdot distance\right) \cdot 2} + velocity \cdot velocity} - velocity}{acceleration} \]

      6. lower-fma.f64N/A

        \[\leadsto \frac{\sqrt{\color{blue}{\mathsf{fma}\left(acceleration \cdot distance, 2, velocity \cdot velocity\right)}} - velocity}{acceleration} \]

      7. *-commutativeN/A

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(\color{blue}{distance \cdot acceleration}, 2, velocity \cdot velocity\right)} - velocity}{acceleration} \]

      8. lower-*.f6473.5

        \[\leadsto \frac{\sqrt{\mathsf{fma}\left(\color{blue}{distance \cdot acceleration}, 2, velocity \cdot velocity\right)} - velocity}{acceleration} \]

    4. Applied rewrites73.5%

      \[\leadsto \frac{\sqrt{\color{blue}{\mathsf{fma}\left(distance \cdot acceleration, 2, velocity \cdot velocity\right)}} - velocity}{acceleration} \]
  3. Recombined 3 regimes into one program.
  4. Add Preprocessing

Alternative 4: 70.9% accurate, 0.7× speedup?

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;velocity \leq -7.4 \cdot 10^{-205}:\\ \;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\ \mathbf{elif}\;velocity \leq 6 \cdot 10^{-262}:\\ \;\;\;\;\sqrt{\frac{distance}{acceleration} \cdot 2} - \frac{velocity}{acceleration}\\ \mathbf{elif}\;velocity \leq 1.95 \cdot 10^{-200}:\\ \;\;\;\;\sqrt{\frac{distance}{acceleration}} \cdot \left(-\sqrt{2}\right)\\ \mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\ \;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \end{array} \]
(FPCore (acceleration distance velocity)
 :precision binary64
 (if (<= velocity -7.4e-205)
   (/ (- (- velocity) velocity) acceleration)
   (if (<= velocity 6e-262)
     (- (sqrt (* (/ distance acceleration) 2.0)) (/ velocity acceleration))
     (if (<= velocity 1.95e-200)
       (* (sqrt (/ distance acceleration)) (- (sqrt 2.0)))
       (if (<= velocity 7.4e-127)
         (/ (- (sqrt (* (* distance acceleration) 2.0)) velocity) acceleration)
         (/ distance velocity))))))
double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -7.4e-205) {
		tmp = (-velocity - velocity) / acceleration;
	} else if (velocity <= 6e-262) {
		tmp = sqrt(((distance / acceleration) * 2.0)) - (velocity / acceleration);
	} else if (velocity <= 1.95e-200) {
		tmp = sqrt((distance / acceleration)) * -sqrt(2.0);
	} else if (velocity <= 7.4e-127) {
		tmp = (sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    real(8) :: tmp
    if (velocity <= (-7.4d-205)) then
        tmp = (-velocity - velocity) / acceleration
    else if (velocity <= 6d-262) then
        tmp = sqrt(((distance / acceleration) * 2.0d0)) - (velocity / acceleration)
    else if (velocity <= 1.95d-200) then
        tmp = sqrt((distance / acceleration)) * -sqrt(2.0d0)
    else if (velocity <= 7.4d-127) then
        tmp = (sqrt(((distance * acceleration) * 2.0d0)) - velocity) / acceleration
    else
        tmp = distance / velocity
    end if
    code = tmp
end function

public static double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -7.4e-205) {
		tmp = (-velocity - velocity) / acceleration;
	} else if (velocity <= 6e-262) {
		tmp = Math.sqrt(((distance / acceleration) * 2.0)) - (velocity / acceleration);
	} else if (velocity <= 1.95e-200) {
		tmp = Math.sqrt((distance / acceleration)) * -Math.sqrt(2.0);
	} else if (velocity <= 7.4e-127) {
		tmp = (Math.sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

def code(acceleration, distance, velocity):
	tmp = 0
	if velocity <= -7.4e-205:
		tmp = (-velocity - velocity) / acceleration
	elif velocity <= 6e-262:
		tmp = math.sqrt(((distance / acceleration) * 2.0)) - (velocity / acceleration)
	elif velocity <= 1.95e-200:
		tmp = math.sqrt((distance / acceleration)) * -math.sqrt(2.0)
	elif velocity <= 7.4e-127:
		tmp = (math.sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration
	else:
		tmp = distance / velocity
	return tmp

function code(acceleration, distance, velocity)
	tmp = 0.0
	if (velocity <= -7.4e-205)
		tmp = Float64(Float64(Float64(-velocity) - velocity) / acceleration);
	elseif (velocity <= 6e-262)
		tmp = Float64(sqrt(Float64(Float64(distance / acceleration) * 2.0)) - Float64(velocity / acceleration));
	elseif (velocity <= 1.95e-200)
		tmp = Float64(sqrt(Float64(distance / acceleration)) * Float64(-sqrt(2.0)));
	elseif (velocity <= 7.4e-127)
		tmp = Float64(Float64(sqrt(Float64(Float64(distance * acceleration) * 2.0)) - velocity) / acceleration);
	else
		tmp = Float64(distance / velocity);
	end
	return tmp
end

function tmp_2 = code(acceleration, distance, velocity)
	tmp = 0.0;
	if (velocity <= -7.4e-205)
		tmp = (-velocity - velocity) / acceleration;
	elseif (velocity <= 6e-262)
		tmp = sqrt(((distance / acceleration) * 2.0)) - (velocity / acceleration);
	elseif (velocity <= 1.95e-200)
		tmp = sqrt((distance / acceleration)) * -sqrt(2.0);
	elseif (velocity <= 7.4e-127)
		tmp = (sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	else
		tmp = distance / velocity;
	end
	tmp_2 = tmp;
end

code[acceleration_, distance_, velocity_] := If[LessEqual[velocity, -7.4e-205], N[(N[((-velocity) - velocity), $MachinePrecision] / acceleration), $MachinePrecision], If[LessEqual[velocity, 6e-262], N[(N[Sqrt[N[(N[(distance / acceleration), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] - N[(velocity / acceleration), $MachinePrecision]), $MachinePrecision], If[LessEqual[velocity, 1.95e-200], N[(N[Sqrt[N[(distance / acceleration), $MachinePrecision]], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision], If[LessEqual[velocity, 7.4e-127], N[(N[(N[Sqrt[N[(N[(distance * acceleration), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision], N[(distance / velocity), $MachinePrecision]]]]]

\begin{array}{l}

\\
\begin{array}{l}
\mathbf{if}\;velocity \leq -7.4 \cdot 10^{-205}:\\
\;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\

\mathbf{elif}\;velocity \leq 6 \cdot 10^{-262}:\\
\;\;\;\;\sqrt{\frac{distance}{acceleration} \cdot 2} - \frac{velocity}{acceleration}\\

\mathbf{elif}\;velocity \leq 1.95 \cdot 10^{-200}:\\
\;\;\;\;\sqrt{\frac{distance}{acceleration}} \cdot \left(-\sqrt{2}\right)\\

\mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\
\;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\

\mathbf{else}:\\
\;\;\;\;\frac{distance}{velocity}\\


\end{array}
\end{array}
Derivation
  1. Split input into 5 regimes

  2. if velocity < -7.4000000000000002e-205

    1. Initial program 88.0%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing

    3. Taylor expanded in velocity around -inf

      \[\leadsto \frac{\color{blue}{-1 \cdot velocity} - velocity}{acceleration} \]
    4. Step-by-step derivation

      1. mul-1-negN/A

        \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(velocity\right)\right)} - velocity}{acceleration} \]

      2. lower-neg.f6482.4

        \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

    5. Applied rewrites82.4%

      \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

    if -7.4000000000000002e-205 < velocity < 6.00000000000000036e-262

    1. Initial program 54.4%

      \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
    2. Add Preprocessing

    3. Taylor expanded in acceleration around inf

      \[\leadsto \color{blue}{-1 \cdot \frac{velocity}{acceleration} + \sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2}} \]
    4. Step-by-step derivation

      1. +-commutativeN/A

        \[\leadsto \color{blue}{\sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2} + -1 \cdot \frac{velocity}{acceleration}} \]

      2. *-commutativeN/A

        \[\leadsto \color{blue}{\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}} + -1 \cdot \frac{velocity}{acceleration} \]

      3. lower-fma.f64N/A

        \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right)} \]

      4. lower-sqrt.f64N/A

        \[\leadsto \mathsf{fma}\left(\color{blue}{\sqrt{2}}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

      5. lower-sqrt.f64N/A

        \[\leadsto \mathsf{fma}\left(\sqrt{2}, \color{blue}{\sqrt{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

      6. lower-/.f64N/A

        \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\color{blue}{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

      7. associate-*r/N/A

        \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{-1 \cdot velocity}{acceleration}}\right) \]

      8. mul-1-negN/A

        \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{\mathsf{neg}\left(velocity\right)}}{acceleration}\right) \]

      9. lower-/.f64N/A

        \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{\mathsf{neg}\left(velocity\right)}{acceleration}}\right) \]

      10. lower-neg.f6461.2

        \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{-velocity}}{acceleration}\right) \]

    5. Applied rewrites61.2%

      \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{-velocity}{acceleration}\right)} \]
    6. Step-by-step derivation

      1. Applied rewrites61.7%

        \[\leadsto \color{blue}{\sqrt{\frac{distance}{acceleration} \cdot 2} - \frac{velocity}{acceleration}} \]

      if 6.00000000000000036e-262 < velocity < 1.94999999999999999e-200

      1. Initial program 37.5%

        \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
      2. Add Preprocessing

      3. Taylor expanded in acceleration around inf

        \[\leadsto \color{blue}{-1 \cdot \frac{velocity}{acceleration} + \sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2}} \]
      4. Step-by-step derivation

        1. +-commutativeN/A

          \[\leadsto \color{blue}{\sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2} + -1 \cdot \frac{velocity}{acceleration}} \]

        2. *-commutativeN/A

          \[\leadsto \color{blue}{\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}} + -1 \cdot \frac{velocity}{acceleration} \]

        3. lower-fma.f64N/A

          \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right)} \]

        4. lower-sqrt.f64N/A

          \[\leadsto \mathsf{fma}\left(\color{blue}{\sqrt{2}}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

        5. lower-sqrt.f64N/A

          \[\leadsto \mathsf{fma}\left(\sqrt{2}, \color{blue}{\sqrt{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

        6. lower-/.f64N/A

          \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\color{blue}{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

        7. associate-*r/N/A

          \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{-1 \cdot velocity}{acceleration}}\right) \]

        8. mul-1-negN/A

          \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{\mathsf{neg}\left(velocity\right)}}{acceleration}\right) \]

        9. lower-/.f64N/A

          \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{\mathsf{neg}\left(velocity\right)}{acceleration}}\right) \]

        10. lower-neg.f6410.9

          \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{-velocity}}{acceleration}\right) \]

      5. Applied rewrites10.9%

        \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{-velocity}{acceleration}\right)} \]

      6. Taylor expanded in acceleration around -inf

        \[\leadsto \sqrt{\frac{distance}{acceleration}} \cdot \color{blue}{\left({\left(\sqrt{-1}\right)}^{2} \cdot \sqrt{2}\right)} \]
      7. Step-by-step derivation

        1. Applied rewrites72.2%

          \[\leadsto \left(-\sqrt{\frac{distance}{acceleration}}\right) \cdot \color{blue}{\sqrt{2}} \]

        if 1.94999999999999999e-200 < velocity < 7.40000000000000078e-127

        1. Initial program 65.7%

          \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
        2. Add Preprocessing

        3. Taylor expanded in acceleration around inf

          \[\leadsto \frac{\sqrt{\color{blue}{2 \cdot \left(acceleration \cdot distance\right)}} - velocity}{acceleration} \]
        4. Step-by-step derivation

          1. *-commutativeN/A

            \[\leadsto \frac{\sqrt{\color{blue}{\left(acceleration \cdot distance\right) \cdot 2}} - velocity}{acceleration} \]

          2. lower-*.f64N/A

            \[\leadsto \frac{\sqrt{\color{blue}{\left(acceleration \cdot distance\right) \cdot 2}} - velocity}{acceleration} \]

          3. *-commutativeN/A

            \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right)} \cdot 2} - velocity}{acceleration} \]

          4. lower-*.f6463.5

            \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right)} \cdot 2} - velocity}{acceleration} \]

        5. Applied rewrites63.5%

          \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right) \cdot 2}} - velocity}{acceleration} \]

        if 7.40000000000000078e-127 < velocity

        1. Initial program 16.2%

          \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
        2. Add Preprocessing

        3. Taylor expanded in acceleration around 0

          \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
        4. Step-by-step derivation

          1. lower-/.f6488.8

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

        5. Applied rewrites88.8%

          \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
      8. Recombined 5 regimes into one program.

      9. Final simplification77.4%

        \[\leadsto \begin{array}{l} \mathbf{if}\;velocity \leq -7.4 \cdot 10^{-205}:\\ \;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\ \mathbf{elif}\;velocity \leq 6 \cdot 10^{-262}:\\ \;\;\;\;\sqrt{\frac{distance}{acceleration} \cdot 2} - \frac{velocity}{acceleration}\\ \mathbf{elif}\;velocity \leq 1.95 \cdot 10^{-200}:\\ \;\;\;\;\sqrt{\frac{distance}{acceleration}} \cdot \left(-\sqrt{2}\right)\\ \mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\ \;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \]
      10. Add Preprocessing

      Alternative 5: 70.7% accurate, 0.7× speedup?

      \[\begin{array}{l} \\ \begin{array}{l} t_0 := \sqrt{\frac{distance}{acceleration}}\\ \mathbf{if}\;velocity \leq -7.4 \cdot 10^{-205}:\\ \;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\ \mathbf{elif}\;velocity \leq 6 \cdot 10^{-262}:\\ \;\;\;\;\sqrt{2} \cdot t\_0\\ \mathbf{elif}\;velocity \leq 1.95 \cdot 10^{-200}:\\ \;\;\;\;t\_0 \cdot \left(-\sqrt{2}\right)\\ \mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\ \;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \end{array} \]
      (FPCore (acceleration distance velocity)
 :precision binary64
 (let* ((t_0 (sqrt (/ distance acceleration))))
   (if (<= velocity -7.4e-205)
     (/ (- (- velocity) velocity) acceleration)
     (if (<= velocity 6e-262)
       (* (sqrt 2.0) t_0)
       (if (<= velocity 1.95e-200)
         (* t_0 (- (sqrt 2.0)))
         (if (<= velocity 7.4e-127)
           (/
            (- (sqrt (* (* distance acceleration) 2.0)) velocity)
            acceleration)
           (/ distance velocity)))))))
      double code(double acceleration, double distance, double velocity) {
	double t_0 = sqrt((distance / acceleration));
	double tmp;
	if (velocity <= -7.4e-205) {
		tmp = (-velocity - velocity) / acceleration;
	} else if (velocity <= 6e-262) {
		tmp = sqrt(2.0) * t_0;
	} else if (velocity <= 1.95e-200) {
		tmp = t_0 * -sqrt(2.0);
	} else if (velocity <= 7.4e-127) {
		tmp = (sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

      real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    real(8) :: t_0
    real(8) :: tmp
    t_0 = sqrt((distance / acceleration))
    if (velocity <= (-7.4d-205)) then
        tmp = (-velocity - velocity) / acceleration
    else if (velocity <= 6d-262) then
        tmp = sqrt(2.0d0) * t_0
    else if (velocity <= 1.95d-200) then
        tmp = t_0 * -sqrt(2.0d0)
    else if (velocity <= 7.4d-127) then
        tmp = (sqrt(((distance * acceleration) * 2.0d0)) - velocity) / acceleration
    else
        tmp = distance / velocity
    end if
    code = tmp
end function

      public static double code(double acceleration, double distance, double velocity) {
	double t_0 = Math.sqrt((distance / acceleration));
	double tmp;
	if (velocity <= -7.4e-205) {
		tmp = (-velocity - velocity) / acceleration;
	} else if (velocity <= 6e-262) {
		tmp = Math.sqrt(2.0) * t_0;
	} else if (velocity <= 1.95e-200) {
		tmp = t_0 * -Math.sqrt(2.0);
	} else if (velocity <= 7.4e-127) {
		tmp = (Math.sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

      def code(acceleration, distance, velocity):
	t_0 = math.sqrt((distance / acceleration))
	tmp = 0
	if velocity <= -7.4e-205:
		tmp = (-velocity - velocity) / acceleration
	elif velocity <= 6e-262:
		tmp = math.sqrt(2.0) * t_0
	elif velocity <= 1.95e-200:
		tmp = t_0 * -math.sqrt(2.0)
	elif velocity <= 7.4e-127:
		tmp = (math.sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration
	else:
		tmp = distance / velocity
	return tmp

      function code(acceleration, distance, velocity)
	t_0 = sqrt(Float64(distance / acceleration))
	tmp = 0.0
	if (velocity <= -7.4e-205)
		tmp = Float64(Float64(Float64(-velocity) - velocity) / acceleration);
	elseif (velocity <= 6e-262)
		tmp = Float64(sqrt(2.0) * t_0);
	elseif (velocity <= 1.95e-200)
		tmp = Float64(t_0 * Float64(-sqrt(2.0)));
	elseif (velocity <= 7.4e-127)
		tmp = Float64(Float64(sqrt(Float64(Float64(distance * acceleration) * 2.0)) - velocity) / acceleration);
	else
		tmp = Float64(distance / velocity);
	end
	return tmp
end

      function tmp_2 = code(acceleration, distance, velocity)
	t_0 = sqrt((distance / acceleration));
	tmp = 0.0;
	if (velocity <= -7.4e-205)
		tmp = (-velocity - velocity) / acceleration;
	elseif (velocity <= 6e-262)
		tmp = sqrt(2.0) * t_0;
	elseif (velocity <= 1.95e-200)
		tmp = t_0 * -sqrt(2.0);
	elseif (velocity <= 7.4e-127)
		tmp = (sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	else
		tmp = distance / velocity;
	end
	tmp_2 = tmp;
end

      code[acceleration_, distance_, velocity_] := Block[{t$95$0 = N[Sqrt[N[(distance / acceleration), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[velocity, -7.4e-205], N[(N[((-velocity) - velocity), $MachinePrecision] / acceleration), $MachinePrecision], If[LessEqual[velocity, 6e-262], N[(N[Sqrt[2.0], $MachinePrecision] * t$95$0), $MachinePrecision], If[LessEqual[velocity, 1.95e-200], N[(t$95$0 * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision], If[LessEqual[velocity, 7.4e-127], N[(N[(N[Sqrt[N[(N[(distance * acceleration), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision], N[(distance / velocity), $MachinePrecision]]]]]]

      \begin{array}{l}

\\
\begin{array}{l}
t_0 := \sqrt{\frac{distance}{acceleration}}\\
\mathbf{if}\;velocity \leq -7.4 \cdot 10^{-205}:\\
\;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\

\mathbf{elif}\;velocity \leq 6 \cdot 10^{-262}:\\
\;\;\;\;\sqrt{2} \cdot t\_0\\

\mathbf{elif}\;velocity \leq 1.95 \cdot 10^{-200}:\\
\;\;\;\;t\_0 \cdot \left(-\sqrt{2}\right)\\

\mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\
\;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\

\mathbf{else}:\\
\;\;\;\;\frac{distance}{velocity}\\


\end{array}
\end{array}
      Derivation
      1. Split input into 5 regimes

      2. if velocity < -7.4000000000000002e-205

        1. Initial program 88.0%

          \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
        2. Add Preprocessing

        3. Taylor expanded in velocity around -inf

          \[\leadsto \frac{\color{blue}{-1 \cdot velocity} - velocity}{acceleration} \]
        4. Step-by-step derivation

          1. mul-1-negN/A

            \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(velocity\right)\right)} - velocity}{acceleration} \]

          2. lower-neg.f6482.4

            \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

        5. Applied rewrites82.4%

          \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

        if -7.4000000000000002e-205 < velocity < 6.00000000000000036e-262

        1. Initial program 54.4%

          \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
        2. Add Preprocessing

        3. Taylor expanded in acceleration around inf

          \[\leadsto \color{blue}{\sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2}} \]
        4. Step-by-step derivation

          1. *-commutativeN/A

            \[\leadsto \color{blue}{\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}} \]

          2. lower-*.f64N/A

            \[\leadsto \color{blue}{\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}} \]

          3. lower-sqrt.f64N/A

            \[\leadsto \color{blue}{\sqrt{2}} \cdot \sqrt{\frac{distance}{acceleration}} \]

          4. lower-sqrt.f64N/A

            \[\leadsto \sqrt{2} \cdot \color{blue}{\sqrt{\frac{distance}{acceleration}}} \]

          5. lower-/.f6460.3

            \[\leadsto \sqrt{2} \cdot \sqrt{\color{blue}{\frac{distance}{acceleration}}} \]

        5. Applied rewrites60.3%

          \[\leadsto \color{blue}{\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}} \]

        if 6.00000000000000036e-262 < velocity < 1.94999999999999999e-200

        1. Initial program 37.5%

          \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
        2. Add Preprocessing

        3. Taylor expanded in acceleration around inf

          \[\leadsto \color{blue}{-1 \cdot \frac{velocity}{acceleration} + \sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2}} \]
        4. Step-by-step derivation

          1. +-commutativeN/A

            \[\leadsto \color{blue}{\sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2} + -1 \cdot \frac{velocity}{acceleration}} \]

          2. *-commutativeN/A

            \[\leadsto \color{blue}{\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}} + -1 \cdot \frac{velocity}{acceleration} \]

          3. lower-fma.f64N/A

            \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right)} \]

          4. lower-sqrt.f64N/A

            \[\leadsto \mathsf{fma}\left(\color{blue}{\sqrt{2}}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

          5. lower-sqrt.f64N/A

            \[\leadsto \mathsf{fma}\left(\sqrt{2}, \color{blue}{\sqrt{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

          6. lower-/.f64N/A

            \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\color{blue}{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

          7. associate-*r/N/A

            \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{-1 \cdot velocity}{acceleration}}\right) \]

          8. mul-1-negN/A

            \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{\mathsf{neg}\left(velocity\right)}}{acceleration}\right) \]

          9. lower-/.f64N/A

            \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{\mathsf{neg}\left(velocity\right)}{acceleration}}\right) \]

          10. lower-neg.f6410.9

            \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{-velocity}}{acceleration}\right) \]

        5. Applied rewrites10.9%

          \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{-velocity}{acceleration}\right)} \]

        6. Taylor expanded in acceleration around -inf

          \[\leadsto \sqrt{\frac{distance}{acceleration}} \cdot \color{blue}{\left({\left(\sqrt{-1}\right)}^{2} \cdot \sqrt{2}\right)} \]
        7. Step-by-step derivation

          1. Applied rewrites72.2%

            \[\leadsto \left(-\sqrt{\frac{distance}{acceleration}}\right) \cdot \color{blue}{\sqrt{2}} \]

          if 1.94999999999999999e-200 < velocity < 7.40000000000000078e-127

          1. Initial program 65.7%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in acceleration around inf

            \[\leadsto \frac{\sqrt{\color{blue}{2 \cdot \left(acceleration \cdot distance\right)}} - velocity}{acceleration} \]
          4. Step-by-step derivation

            1. *-commutativeN/A

              \[\leadsto \frac{\sqrt{\color{blue}{\left(acceleration \cdot distance\right) \cdot 2}} - velocity}{acceleration} \]

            2. lower-*.f64N/A

              \[\leadsto \frac{\sqrt{\color{blue}{\left(acceleration \cdot distance\right) \cdot 2}} - velocity}{acceleration} \]

            3. *-commutativeN/A

              \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right)} \cdot 2} - velocity}{acceleration} \]

            4. lower-*.f6463.5

              \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right)} \cdot 2} - velocity}{acceleration} \]

          5. Applied rewrites63.5%

            \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right) \cdot 2}} - velocity}{acceleration} \]

          if 7.40000000000000078e-127 < velocity

          1. Initial program 16.2%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in acceleration around 0

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
          4. Step-by-step derivation

            1. lower-/.f6488.8

              \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

          5. Applied rewrites88.8%

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
        8. Recombined 5 regimes into one program.

        9. Final simplification77.2%

          \[\leadsto \begin{array}{l} \mathbf{if}\;velocity \leq -7.4 \cdot 10^{-205}:\\ \;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\ \mathbf{elif}\;velocity \leq 6 \cdot 10^{-262}:\\ \;\;\;\;\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}\\ \mathbf{elif}\;velocity \leq 1.95 \cdot 10^{-200}:\\ \;\;\;\;\sqrt{\frac{distance}{acceleration}} \cdot \left(-\sqrt{2}\right)\\ \mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\ \;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \]
        10. Add Preprocessing

        Alternative 6: 72.9% accurate, 0.9× speedup?

        \[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;velocity \leq -1.5 \cdot 10^{-205}:\\ \;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\ \mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\ \;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \end{array} \]
        (FPCore (acceleration distance velocity)
 :precision binary64
 (if (<= velocity -1.5e-205)
   (/ (- (- velocity) velocity) acceleration)
   (if (<= velocity 7.4e-127)
     (/ (- (sqrt (* (* distance acceleration) 2.0)) velocity) acceleration)
     (/ distance velocity))))
        double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -1.5e-205) {
		tmp = (-velocity - velocity) / acceleration;
	} else if (velocity <= 7.4e-127) {
		tmp = (sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

        real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    real(8) :: tmp
    if (velocity <= (-1.5d-205)) then
        tmp = (-velocity - velocity) / acceleration
    else if (velocity <= 7.4d-127) then
        tmp = (sqrt(((distance * acceleration) * 2.0d0)) - velocity) / acceleration
    else
        tmp = distance / velocity
    end if
    code = tmp
end function

        public static double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -1.5e-205) {
		tmp = (-velocity - velocity) / acceleration;
	} else if (velocity <= 7.4e-127) {
		tmp = (Math.sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

        def code(acceleration, distance, velocity):
	tmp = 0
	if velocity <= -1.5e-205:
		tmp = (-velocity - velocity) / acceleration
	elif velocity <= 7.4e-127:
		tmp = (math.sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration
	else:
		tmp = distance / velocity
	return tmp

        function code(acceleration, distance, velocity)
	tmp = 0.0
	if (velocity <= -1.5e-205)
		tmp = Float64(Float64(Float64(-velocity) - velocity) / acceleration);
	elseif (velocity <= 7.4e-127)
		tmp = Float64(Float64(sqrt(Float64(Float64(distance * acceleration) * 2.0)) - velocity) / acceleration);
	else
		tmp = Float64(distance / velocity);
	end
	return tmp
end

        function tmp_2 = code(acceleration, distance, velocity)
	tmp = 0.0;
	if (velocity <= -1.5e-205)
		tmp = (-velocity - velocity) / acceleration;
	elseif (velocity <= 7.4e-127)
		tmp = (sqrt(((distance * acceleration) * 2.0)) - velocity) / acceleration;
	else
		tmp = distance / velocity;
	end
	tmp_2 = tmp;
end

        code[acceleration_, distance_, velocity_] := If[LessEqual[velocity, -1.5e-205], N[(N[((-velocity) - velocity), $MachinePrecision] / acceleration), $MachinePrecision], If[LessEqual[velocity, 7.4e-127], N[(N[(N[Sqrt[N[(N[(distance * acceleration), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] - velocity), $MachinePrecision] / acceleration), $MachinePrecision], N[(distance / velocity), $MachinePrecision]]]

        \begin{array}{l}

\\
\begin{array}{l}
\mathbf{if}\;velocity \leq -1.5 \cdot 10^{-205}:\\
\;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\

\mathbf{elif}\;velocity \leq 7.4 \cdot 10^{-127}:\\
\;\;\;\;\frac{\sqrt{\left(distance \cdot acceleration\right) \cdot 2} - velocity}{acceleration}\\

\mathbf{else}:\\
\;\;\;\;\frac{distance}{velocity}\\


\end{array}
\end{array}
        Derivation
        1. Split input into 3 regimes

        2. if velocity < -1.5e-205

          1. Initial program 86.4%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in velocity around -inf

            \[\leadsto \frac{\color{blue}{-1 \cdot velocity} - velocity}{acceleration} \]
          4. Step-by-step derivation

            1. mul-1-negN/A

              \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(velocity\right)\right)} - velocity}{acceleration} \]

            2. lower-neg.f6481.2

              \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

          5. Applied rewrites81.2%

            \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

          if -1.5e-205 < velocity < 7.40000000000000078e-127

          1. Initial program 55.7%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in acceleration around inf

            \[\leadsto \frac{\sqrt{\color{blue}{2 \cdot \left(acceleration \cdot distance\right)}} - velocity}{acceleration} \]
          4. Step-by-step derivation

            1. *-commutativeN/A

              \[\leadsto \frac{\sqrt{\color{blue}{\left(acceleration \cdot distance\right) \cdot 2}} - velocity}{acceleration} \]

            2. lower-*.f64N/A

              \[\leadsto \frac{\sqrt{\color{blue}{\left(acceleration \cdot distance\right) \cdot 2}} - velocity}{acceleration} \]

            3. *-commutativeN/A

              \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right)} \cdot 2} - velocity}{acceleration} \]

            4. lower-*.f6454.8

              \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right)} \cdot 2} - velocity}{acceleration} \]

          5. Applied rewrites54.8%

            \[\leadsto \frac{\sqrt{\color{blue}{\left(distance \cdot acceleration\right) \cdot 2}} - velocity}{acceleration} \]

          if 7.40000000000000078e-127 < velocity

          1. Initial program 16.2%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in acceleration around 0

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
          4. Step-by-step derivation

            1. lower-/.f6488.8

              \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

          5. Applied rewrites88.8%

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
        3. Recombined 3 regimes into one program.
        4. Add Preprocessing

        Alternative 7: 67.5% accurate, 1.9× speedup?

        \[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;velocity \leq -5 \cdot 10^{-310}:\\ \;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \end{array} \]
        (FPCore (acceleration distance velocity)
 :precision binary64
 (if (<= velocity -5e-310)
   (/ (- (- velocity) velocity) acceleration)
   (/ distance velocity)))
        double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -5e-310) {
		tmp = (-velocity - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

        real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    real(8) :: tmp
    if (velocity <= (-5d-310)) then
        tmp = (-velocity - velocity) / acceleration
    else
        tmp = distance / velocity
    end if
    code = tmp
end function

        public static double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -5e-310) {
		tmp = (-velocity - velocity) / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

        def code(acceleration, distance, velocity):
	tmp = 0
	if velocity <= -5e-310:
		tmp = (-velocity - velocity) / acceleration
	else:
		tmp = distance / velocity
	return tmp

        function code(acceleration, distance, velocity)
	tmp = 0.0
	if (velocity <= -5e-310)
		tmp = Float64(Float64(Float64(-velocity) - velocity) / acceleration);
	else
		tmp = Float64(distance / velocity);
	end
	return tmp
end

        function tmp_2 = code(acceleration, distance, velocity)
	tmp = 0.0;
	if (velocity <= -5e-310)
		tmp = (-velocity - velocity) / acceleration;
	else
		tmp = distance / velocity;
	end
	tmp_2 = tmp;
end

        code[acceleration_, distance_, velocity_] := If[LessEqual[velocity, -5e-310], N[(N[((-velocity) - velocity), $MachinePrecision] / acceleration), $MachinePrecision], N[(distance / velocity), $MachinePrecision]]

        \begin{array}{l}

\\
\begin{array}{l}
\mathbf{if}\;velocity \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\frac{\left(-velocity\right) - velocity}{acceleration}\\

\mathbf{else}:\\
\;\;\;\;\frac{distance}{velocity}\\


\end{array}
\end{array}
        Derivation
        1. Split input into 2 regimes

        2. if velocity < -4.999999999999985e-310

          1. Initial program 79.3%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in velocity around -inf

            \[\leadsto \frac{\color{blue}{-1 \cdot velocity} - velocity}{acceleration} \]
          4. Step-by-step derivation

            1. mul-1-negN/A

              \[\leadsto \frac{\color{blue}{\left(\mathsf{neg}\left(velocity\right)\right)} - velocity}{acceleration} \]

            2. lower-neg.f6466.7

              \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

          5. Applied rewrites66.7%

            \[\leadsto \frac{\color{blue}{\left(-velocity\right)} - velocity}{acceleration} \]

          if -4.999999999999985e-310 < velocity

          1. Initial program 37.2%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in acceleration around 0

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
          4. Step-by-step derivation

            1. lower-/.f6456.6

              \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

          5. Applied rewrites56.6%

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
        3. Recombined 2 regimes into one program.
        4. Add Preprocessing

        Alternative 8: 40.9% accurate, 2.1× speedup?

        \[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;velocity \leq -5 \cdot 10^{-310}:\\ \;\;\;\;\frac{-velocity}{acceleration}\\ \mathbf{else}:\\ \;\;\;\;\frac{distance}{velocity}\\ \end{array} \end{array} \]
        (FPCore (acceleration distance velocity)
 :precision binary64
 (if (<= velocity -5e-310)
   (/ (- velocity) acceleration)
   (/ distance velocity)))
        double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -5e-310) {
		tmp = -velocity / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

        real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    real(8) :: tmp
    if (velocity <= (-5d-310)) then
        tmp = -velocity / acceleration
    else
        tmp = distance / velocity
    end if
    code = tmp
end function

        public static double code(double acceleration, double distance, double velocity) {
	double tmp;
	if (velocity <= -5e-310) {
		tmp = -velocity / acceleration;
	} else {
		tmp = distance / velocity;
	}
	return tmp;
}

        def code(acceleration, distance, velocity):
	tmp = 0
	if velocity <= -5e-310:
		tmp = -velocity / acceleration
	else:
		tmp = distance / velocity
	return tmp

        function code(acceleration, distance, velocity)
	tmp = 0.0
	if (velocity <= -5e-310)
		tmp = Float64(Float64(-velocity) / acceleration);
	else
		tmp = Float64(distance / velocity);
	end
	return tmp
end

        function tmp_2 = code(acceleration, distance, velocity)
	tmp = 0.0;
	if (velocity <= -5e-310)
		tmp = -velocity / acceleration;
	else
		tmp = distance / velocity;
	end
	tmp_2 = tmp;
end

        code[acceleration_, distance_, velocity_] := If[LessEqual[velocity, -5e-310], N[((-velocity) / acceleration), $MachinePrecision], N[(distance / velocity), $MachinePrecision]]

        \begin{array}{l}

\\
\begin{array}{l}
\mathbf{if}\;velocity \leq -5 \cdot 10^{-310}:\\
\;\;\;\;\frac{-velocity}{acceleration}\\

\mathbf{else}:\\
\;\;\;\;\frac{distance}{velocity}\\


\end{array}
\end{array}
        Derivation
        1. Split input into 2 regimes

        2. if velocity < -4.999999999999985e-310

          1. Initial program 79.3%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in acceleration around inf

            \[\leadsto \color{blue}{-1 \cdot \frac{velocity}{acceleration} + \sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2}} \]
          4. Step-by-step derivation

            1. +-commutativeN/A

              \[\leadsto \color{blue}{\sqrt{\frac{distance}{acceleration}} \cdot \sqrt{2} + -1 \cdot \frac{velocity}{acceleration}} \]

            2. *-commutativeN/A

              \[\leadsto \color{blue}{\sqrt{2} \cdot \sqrt{\frac{distance}{acceleration}}} + -1 \cdot \frac{velocity}{acceleration} \]

            3. lower-fma.f64N/A

              \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right)} \]

            4. lower-sqrt.f64N/A

              \[\leadsto \mathsf{fma}\left(\color{blue}{\sqrt{2}}, \sqrt{\frac{distance}{acceleration}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

            5. lower-sqrt.f64N/A

              \[\leadsto \mathsf{fma}\left(\sqrt{2}, \color{blue}{\sqrt{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

            6. lower-/.f64N/A

              \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\color{blue}{\frac{distance}{acceleration}}}, -1 \cdot \frac{velocity}{acceleration}\right) \]

            7. associate-*r/N/A

              \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{-1 \cdot velocity}{acceleration}}\right) \]

            8. mul-1-negN/A

              \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{\mathsf{neg}\left(velocity\right)}}{acceleration}\right) \]

            9. lower-/.f64N/A

              \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \color{blue}{\frac{\mathsf{neg}\left(velocity\right)}{acceleration}}\right) \]

            10. lower-neg.f6422.4

              \[\leadsto \mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{\color{blue}{-velocity}}{acceleration}\right) \]

          5. Applied rewrites22.4%

            \[\leadsto \color{blue}{\mathsf{fma}\left(\sqrt{2}, \sqrt{\frac{distance}{acceleration}}, \frac{-velocity}{acceleration}\right)} \]

          6. Taylor expanded in velocity around inf

            \[\leadsto -1 \cdot \color{blue}{\frac{velocity}{acceleration}} \]
          7. Step-by-step derivation

            1. Applied rewrites14.9%

              \[\leadsto \frac{-velocity}{\color{blue}{acceleration}} \]

            if -4.999999999999985e-310 < velocity

            1. Initial program 37.2%

              \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
            2. Add Preprocessing

            3. Taylor expanded in acceleration around 0

              \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
            4. Step-by-step derivation

              1. lower-/.f6456.6

                \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

            5. Applied rewrites56.6%

              \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
          8. Recombined 2 regimes into one program.
          9. Add Preprocessing

          Alternative 9: 34.9% accurate, 3.6× speedup?

          \[\begin{array}{l} \\ \frac{distance}{velocity} \end{array} \]
          (FPCore (acceleration distance velocity)
 :precision binary64
 (/ distance velocity))
          double code(double acceleration, double distance, double velocity) {
	return distance / velocity;
}

          real(8) function code(acceleration, distance, velocity)
    real(8), intent (in) :: acceleration
    real(8), intent (in) :: distance
    real(8), intent (in) :: velocity
    code = distance / velocity
end function

          public static double code(double acceleration, double distance, double velocity) {
	return distance / velocity;
}

          def code(acceleration, distance, velocity):
	return distance / velocity

          function code(acceleration, distance, velocity)
	return Float64(distance / velocity)
end

          function tmp = code(acceleration, distance, velocity)
	tmp = distance / velocity;
end

          code[acceleration_, distance_, velocity_] := N[(distance / velocity), $MachinePrecision]

          \begin{array}{l}

\\
\frac{distance}{velocity}
\end{array}
          Derivation

          1. Initial program 55.8%

            \[\frac{\sqrt{\left(2 \cdot acceleration\right) \cdot distance + velocity \cdot velocity} - velocity}{acceleration} \]
          2. Add Preprocessing

          3. Taylor expanded in acceleration around 0

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
          4. Step-by-step derivation

            1. lower-/.f6432.8

              \[\leadsto \color{blue}{\frac{distance}{velocity}} \]

          5. Applied rewrites32.8%

            \[\leadsto \color{blue}{\frac{distance}{velocity}} \]
          6. Add Preprocessing

          Reproduce

          ?
          herbie shell --seed 1 
(FPCore (acceleration distance velocity)
  :name "(sqrt(2 * acceleration * distance + velocity * velocity) - velocity) / acceleration"
  :precision binary64
  :pre (and (and (and (<= -100000.0 acceleration) (<= acceleration 100000.0)) (and (<= -0.0001 distance) (<= distance 0.0001))) (and (<= -1000.0 velocity) (<= velocity 1000.0)))
  (/ (- (sqrt (+ (* (* 2.0 acceleration) distance) (* velocity velocity))) velocity) acceleration))