Rosa's DopplerBench

Percentage Accurate: 72.7% → 96.5%

Time: 5.8s

Alternatives: 9

Speedup: 0.8×

Specification

Math

\[\begin{array}{l} \\ \frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \end{array} \]

FPCore

(FPCore (u v t1) :precision binary64 (/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))

C

double code(double u, double v, double t1) {
	return (-t1 * v) / ((t1 + u) * (t1 + u));
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    code = (-t1 * v) / ((t1 + u) * (t1 + u))
end function

Java

public static double code(double u, double v, double t1) {
	return (-t1 * v) / ((t1 + u) * (t1 + u));
}

Python

def code(u, v, t1):
	return (-t1 * v) / ((t1 + u) * (t1 + u))

Julia

function code(u, v, t1)
	return Float64(Float64(Float64(-t1) * v) / Float64(Float64(t1 + u) * Float64(t1 + u)))
end

MATLAB

function tmp = code(u, v, t1)
	tmp = (-t1 * v) / ((t1 + u) * (t1 + u));
end

Wolfram

code[u_, v_, t1_] := N[(N[((-t1) * v), $MachinePrecision] / N[(N[(t1 + u), $MachinePrecision] * N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 72.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \end{array} \]

FPCore

(FPCore (u v t1) :precision binary64 (/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))

C

double code(double u, double v, double t1) {
	return (-t1 * v) / ((t1 + u) * (t1 + u));
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    code = (-t1 * v) / ((t1 + u) * (t1 + u))
end function

Java

public static double code(double u, double v, double t1) {
	return (-t1 * v) / ((t1 + u) * (t1 + u));
}

Python

def code(u, v, t1):
	return (-t1 * v) / ((t1 + u) * (t1 + u))

Julia

function code(u, v, t1)
	return Float64(Float64(Float64(-t1) * v) / Float64(Float64(t1 + u) * Float64(t1 + u)))
end

MATLAB

function tmp = code(u, v, t1)
	tmp = (-t1 * v) / ((t1 + u) * (t1 + u));
end

Wolfram

code[u_, v_, t1_] := N[(N[((-t1) * v), $MachinePrecision] / N[(N[(t1 + u), $MachinePrecision] * N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 96.5% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{t1}{u - t1} \cdot v}{\left(-u\right) + t1} \end{array} \]

FPCore

(FPCore (u v t1) :precision binary64 (/ (* (/ t1 (- u t1)) v) (+ (- u) t1)))

C

double code(double u, double v, double t1) {
	return ((t1 / (u - t1)) * v) / (-u + t1);
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    code = ((t1 / (u - t1)) * v) / (-u + t1)
end function

Java

public static double code(double u, double v, double t1) {
	return ((t1 / (u - t1)) * v) / (-u + t1);
}

Python

def code(u, v, t1):
	return ((t1 / (u - t1)) * v) / (-u + t1)

Julia

function code(u, v, t1)
	return Float64(Float64(Float64(t1 / Float64(u - t1)) * v) / Float64(Float64(-u) + t1))
end

MATLAB

function tmp = code(u, v, t1)
	tmp = ((t1 / (u - t1)) * v) / (-u + t1);
end

Wolfram

code[u_, v_, t1_] := N[(N[(N[(t1 / N[(u - t1), $MachinePrecision]), $MachinePrecision] * v), $MachinePrecision] / N[((-u) + t1), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 73.9%

   \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
2. Add Preprocessing

4. Applied rewrites 97.2%

   \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

5. Final simplification 97.2%

   \[\leadsto \frac{\frac{t1}{u - t1} \cdot v}{\left(-u\right) + t1} \]
6. Add Preprocessing

Alternative 2: 86.7% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)}\\ \mathbf{if}\;t1 \leq -1.2 \cdot 10^{+154}:\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{elif}\;t1 \leq -3 \cdot 10^{-102}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t1 \leq 2.7 \cdot 10^{-138}:\\ \;\;\;\;\frac{\frac{-v}{u} \cdot t1}{u}\\ \mathbf{elif}\;t1 \leq 1.3 \cdot 10^{+110}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (let* ((t_1 (/ (* (- t1) v) (* (+ t1 u) (+ t1 u)))))
   (if (<= t1 -1.2e+154)
     (/ (* -1.0 v) (- t1 u))
     (if (<= t1 -3e-102)
       t_1
       (if (<= t1 2.7e-138)
         (/ (* (/ (- v) u) t1) u)
         (if (<= t1 1.3e+110) t_1 (/ (- v) t1)))))))

C

double code(double u, double v, double t1) {
	double t_1 = (-t1 * v) / ((t1 + u) * (t1 + u));
	double tmp;
	if (t1 <= -1.2e+154) {
		tmp = (-1.0 * v) / (t1 - u);
	} else if (t1 <= -3e-102) {
		tmp = t_1;
	} else if (t1 <= 2.7e-138) {
		tmp = ((-v / u) * t1) / u;
	} else if (t1 <= 1.3e+110) {
		tmp = t_1;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    real(8) :: t_1
    real(8) :: tmp
    t_1 = (-t1 * v) / ((t1 + u) * (t1 + u))
    if (t1 <= (-1.2d+154)) then
        tmp = ((-1.0d0) * v) / (t1 - u)
    else if (t1 <= (-3d-102)) then
        tmp = t_1
    else if (t1 <= 2.7d-138) then
        tmp = ((-v / u) * t1) / u
    else if (t1 <= 1.3d+110) then
        tmp = t_1
    else
        tmp = -v / t1
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double t_1 = (-t1 * v) / ((t1 + u) * (t1 + u));
	double tmp;
	if (t1 <= -1.2e+154) {
		tmp = (-1.0 * v) / (t1 - u);
	} else if (t1 <= -3e-102) {
		tmp = t_1;
	} else if (t1 <= 2.7e-138) {
		tmp = ((-v / u) * t1) / u;
	} else if (t1 <= 1.3e+110) {
		tmp = t_1;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	t_1 = (-t1 * v) / ((t1 + u) * (t1 + u))
	tmp = 0
	if t1 <= -1.2e+154:
		tmp = (-1.0 * v) / (t1 - u)
	elif t1 <= -3e-102:
		tmp = t_1
	elif t1 <= 2.7e-138:
		tmp = ((-v / u) * t1) / u
	elif t1 <= 1.3e+110:
		tmp = t_1
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	t_1 = Float64(Float64(Float64(-t1) * v) / Float64(Float64(t1 + u) * Float64(t1 + u)))
	tmp = 0.0
	if (t1 <= -1.2e+154)
		tmp = Float64(Float64(-1.0 * v) / Float64(t1 - u));
	elseif (t1 <= -3e-102)
		tmp = t_1;
	elseif (t1 <= 2.7e-138)
		tmp = Float64(Float64(Float64(Float64(-v) / u) * t1) / u);
	elseif (t1 <= 1.3e+110)
		tmp = t_1;
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	t_1 = (-t1 * v) / ((t1 + u) * (t1 + u));
	tmp = 0.0;
	if (t1 <= -1.2e+154)
		tmp = (-1.0 * v) / (t1 - u);
	elseif (t1 <= -3e-102)
		tmp = t_1;
	elseif (t1 <= 2.7e-138)
		tmp = ((-v / u) * t1) / u;
	elseif (t1 <= 1.3e+110)
		tmp = t_1;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := Block[{t$95$1 = N[(N[((-t1) * v), $MachinePrecision] / N[(N[(t1 + u), $MachinePrecision] * N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t1, -1.2e+154], N[(N[(-1.0 * v), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision], If[LessEqual[t1, -3e-102], t$95$1, If[LessEqual[t1, 2.7e-138], N[(N[(N[((-v) / u), $MachinePrecision] * t1), $MachinePrecision] / u), $MachinePrecision], If[LessEqual[t1, 1.3e+110], t$95$1, N[((-v) / t1), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if t1 < -1.20000000000000007e154

   1. Initial program 36.5%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   4. Applied rewrites 100.0%

      \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

   5. Taylor expanded in u around 0

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   6. Step-by-step derivation

   7. Applied rewrites 96.8%

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   8. Step-by-step derivation

      1. lift--.f64 N/A

         \[\leadsto \frac{-1 \cdot \left(-v\right)}{\color{blue}{u - t1}} \]

      2. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-v\right)}{u - t1}} \]

      3. lift-*.f64 N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot \left(-v\right)}}{u - t1} \]

      4. *-commutative N/A

         \[\leadsto \frac{\color{blue}{\left(-v\right) \cdot -1}}{u - t1} \]

      5. associate-/l* N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

      8. lift--.f64 96.6

         \[\leadsto \left(-v\right) \cdot \frac{-1}{\color{blue}{u - t1}} \]

   9. Applied rewrites 96.6%

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]
   10. Step-by-step derivation

       1. lift-*.f64 N/A

          \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

       2. lift-/.f64 N/A

          \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

       3. associate-*r/ N/A

          \[\leadsto \color{blue}{\frac{\left(-v\right) \cdot -1}{u - t1}} \]

       4. frac-2neg N/A

          \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\left(u - t1\right)\right)}} \]

       5. lift--.f64 N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\left(u - t1\right)}\right)} \]

       6. flip-- N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\frac{u \cdot u - t1 \cdot t1}{u + t1}}\right)} \]

       7. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\frac{u \cdot u - t1 \cdot t1}{\color{blue}{t1 + u}}\right)} \]

       8. distribute-neg-frac N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\color{blue}{\frac{\mathsf{neg}\left(\left(u \cdot u - t1 \cdot t1\right)\right)}{t1 + u}}} \]

   11. Applied rewrites 96.8%

       \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1 - u}} \]

   if -1.20000000000000007e154 < t1 < -3e-102 or 2.70000000000000029e-138 < t1 < 1.3e110

   1. Initial program 88.5%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   if -3e-102 < t1 < 2.70000000000000029e-138

   1. Initial program 77.7%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in u around inf

      \[\leadsto \color{blue}{-1 \cdot \frac{t1 \cdot v}{{u}^{2}}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t1 \cdot v}{{u}^{2}}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{v \cdot t1}}{{u}^{2}}\right) \]

      3. unpow2 N/A

         \[\leadsto \mathsf{neg}\left(\frac{v \cdot t1}{\color{blue}{u \cdot u}}\right) \]

      4. times-frac N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{v}{u} \cdot \frac{t1}{u}}\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      7. distribute-frac-neg N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(v\right)}{u}} \cdot \frac{t1}{u} \]

      8. mul-1-neg N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot v}}{u} \cdot \frac{t1}{u} \]

      9. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot v}{u}} \cdot \frac{t1}{u} \]

      10. mul-1-neg N/A

          \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(v\right)}}{u} \cdot \frac{t1}{u} \]

      11. lower-neg.f64 N/A

          \[\leadsto \frac{\color{blue}{-v}}{u} \cdot \frac{t1}{u} \]

      12. lower-/.f64 87.8

          \[\leadsto \frac{-v}{u} \cdot \color{blue}{\frac{t1}{u}} \]

   5. Applied rewrites 87.8%

      \[\leadsto \color{blue}{\frac{-v}{u} \cdot \frac{t1}{u}} \]
   6. Step-by-step derivation

   7. Applied rewrites 89.3%

      \[\leadsto \frac{\frac{-v}{u} \cdot t1}{\color{blue}{u}} \]

   if 1.3e110 < t1

   1. Initial program 55.8%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in u around 0

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

      1. associate-*r/ N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1}} \]

      2. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1}} \]

      3. mul-1-neg N/A

         \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(v\right)}}{t1} \]

      4. lower-neg.f64 91.8

         \[\leadsto \frac{\color{blue}{-v}}{t1} \]

   5. Applied rewrites 91.8%

      \[\leadsto \color{blue}{\frac{-v}{t1}} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 3: 79.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 8 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{-v}{u} \cdot t1}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -1.25e-70) (not (<= t1 8e-19)))
   (/ (* -1.0 v) (- t1 u))
   (/ (* (/ (- v) u) t1) u)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 8e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = ((-v / u) * t1) / u;
	}
	return tmp;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    real(8) :: tmp
    if ((t1 <= (-1.25d-70)) .or. (.not. (t1 <= 8d-19))) then
        tmp = ((-1.0d0) * v) / (t1 - u)
    else
        tmp = ((-v / u) * t1) / u
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 8e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = ((-v / u) * t1) / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -1.25e-70) or not (t1 <= 8e-19):
		tmp = (-1.0 * v) / (t1 - u)
	else:
		tmp = ((-v / u) * t1) / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -1.25e-70) || !(t1 <= 8e-19))
		tmp = Float64(Float64(-1.0 * v) / Float64(t1 - u));
	else
		tmp = Float64(Float64(Float64(Float64(-v) / u) * t1) / u);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -1.25e-70) || ~((t1 <= 8e-19)))
		tmp = (-1.0 * v) / (t1 - u);
	else
		tmp = ((-v / u) * t1) / u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.25e-70], N[Not[LessEqual[t1, 8e-19]], $MachinePrecision]], N[(N[(-1.0 * v), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision], N[(N[(N[((-v) / u), $MachinePrecision] * t1), $MachinePrecision] / u), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t1 < -1.25e-70 or 7.9999999999999998e-19 < t1

   1. Initial program 69.9%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   4. Applied rewrites 99.6%

      \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

   5. Taylor expanded in u around 0

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   6. Step-by-step derivation

   7. Applied rewrites 82.6%

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   8. Step-by-step derivation

      1. lift--.f64 N/A

         \[\leadsto \frac{-1 \cdot \left(-v\right)}{\color{blue}{u - t1}} \]

      2. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-v\right)}{u - t1}} \]

      3. lift-*.f64 N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot \left(-v\right)}}{u - t1} \]

      4. *-commutative N/A

         \[\leadsto \frac{\color{blue}{\left(-v\right) \cdot -1}}{u - t1} \]

      5. associate-/l* N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

      8. lift--.f64 82.4

         \[\leadsto \left(-v\right) \cdot \frac{-1}{\color{blue}{u - t1}} \]

   9. Applied rewrites 82.4%

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]
   10. Step-by-step derivation

       1. lift-*.f64 N/A

          \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

       2. lift-/.f64 N/A

          \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

       3. associate-*r/ N/A

          \[\leadsto \color{blue}{\frac{\left(-v\right) \cdot -1}{u - t1}} \]

       4. frac-2neg N/A

          \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\left(u - t1\right)\right)}} \]

       5. lift--.f64 N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\left(u - t1\right)}\right)} \]

       6. flip-- N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\frac{u \cdot u - t1 \cdot t1}{u + t1}}\right)} \]

       7. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\frac{u \cdot u - t1 \cdot t1}{\color{blue}{t1 + u}}\right)} \]

       8. distribute-neg-frac N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\color{blue}{\frac{\mathsf{neg}\left(\left(u \cdot u - t1 \cdot t1\right)\right)}{t1 + u}}} \]

   11. Applied rewrites 82.6%

       \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1 - u}} \]

   if -1.25e-70 < t1 < 7.9999999999999998e-19

   1. Initial program 79.1%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in u around inf

      \[\leadsto \color{blue}{-1 \cdot \frac{t1 \cdot v}{{u}^{2}}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t1 \cdot v}{{u}^{2}}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{v \cdot t1}}{{u}^{2}}\right) \]

      3. unpow2 N/A

         \[\leadsto \mathsf{neg}\left(\frac{v \cdot t1}{\color{blue}{u \cdot u}}\right) \]

      4. times-frac N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{v}{u} \cdot \frac{t1}{u}}\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      7. distribute-frac-neg N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(v\right)}{u}} \cdot \frac{t1}{u} \]

      8. mul-1-neg N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot v}}{u} \cdot \frac{t1}{u} \]

      9. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot v}{u}} \cdot \frac{t1}{u} \]

      10. mul-1-neg N/A

          \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(v\right)}}{u} \cdot \frac{t1}{u} \]

      11. lower-neg.f64 N/A

          \[\leadsto \frac{\color{blue}{-v}}{u} \cdot \frac{t1}{u} \]

      12. lower-/.f64 84.5

          \[\leadsto \frac{-v}{u} \cdot \color{blue}{\frac{t1}{u}} \]

   5. Applied rewrites 84.5%

      \[\leadsto \color{blue}{\frac{-v}{u} \cdot \frac{t1}{u}} \]
   6. Step-by-step derivation

   7. Applied rewrites 85.6%

      \[\leadsto \frac{\frac{-v}{u} \cdot t1}{\color{blue}{u}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 83.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 8 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{-v}{u} \cdot t1}{u}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 79.1% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 8 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{u} \cdot \frac{-t1}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -1.25e-70) (not (<= t1 8e-19)))
   (/ (* -1.0 v) (- t1 u))
   (* (/ v u) (/ (- t1) u))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 8e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = (v / u) * (-t1 / u);
	}
	return tmp;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    real(8) :: tmp
    if ((t1 <= (-1.25d-70)) .or. (.not. (t1 <= 8d-19))) then
        tmp = ((-1.0d0) * v) / (t1 - u)
    else
        tmp = (v / u) * (-t1 / u)
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 8e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = (v / u) * (-t1 / u);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -1.25e-70) or not (t1 <= 8e-19):
		tmp = (-1.0 * v) / (t1 - u)
	else:
		tmp = (v / u) * (-t1 / u)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -1.25e-70) || !(t1 <= 8e-19))
		tmp = Float64(Float64(-1.0 * v) / Float64(t1 - u));
	else
		tmp = Float64(Float64(v / u) * Float64(Float64(-t1) / u));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -1.25e-70) || ~((t1 <= 8e-19)))
		tmp = (-1.0 * v) / (t1 - u);
	else
		tmp = (v / u) * (-t1 / u);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.25e-70], N[Not[LessEqual[t1, 8e-19]], $MachinePrecision]], N[(N[(-1.0 * v), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision], N[(N[(v / u), $MachinePrecision] * N[((-t1) / u), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t1 < -1.25e-70 or 7.9999999999999998e-19 < t1

   1. Initial program 69.9%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   4. Applied rewrites 99.6%

      \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

   5. Taylor expanded in u around 0

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   6. Step-by-step derivation

   7. Applied rewrites 82.6%

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   8. Step-by-step derivation

      1. lift--.f64 N/A

         \[\leadsto \frac{-1 \cdot \left(-v\right)}{\color{blue}{u - t1}} \]

      2. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-v\right)}{u - t1}} \]

      3. lift-*.f64 N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot \left(-v\right)}}{u - t1} \]

      4. *-commutative N/A

         \[\leadsto \frac{\color{blue}{\left(-v\right) \cdot -1}}{u - t1} \]

      5. associate-/l* N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

      8. lift--.f64 82.4

         \[\leadsto \left(-v\right) \cdot \frac{-1}{\color{blue}{u - t1}} \]

   9. Applied rewrites 82.4%

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]
   10. Step-by-step derivation

       1. lift-*.f64 N/A

          \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

       2. lift-/.f64 N/A

          \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

       3. associate-*r/ N/A

          \[\leadsto \color{blue}{\frac{\left(-v\right) \cdot -1}{u - t1}} \]

       4. frac-2neg N/A

          \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\left(u - t1\right)\right)}} \]

       5. lift--.f64 N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\left(u - t1\right)}\right)} \]

       6. flip-- N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\frac{u \cdot u - t1 \cdot t1}{u + t1}}\right)} \]

       7. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\frac{u \cdot u - t1 \cdot t1}{\color{blue}{t1 + u}}\right)} \]

       8. distribute-neg-frac N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\color{blue}{\frac{\mathsf{neg}\left(\left(u \cdot u - t1 \cdot t1\right)\right)}{t1 + u}}} \]

   11. Applied rewrites 82.6%

       \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1 - u}} \]

   if -1.25e-70 < t1 < 7.9999999999999998e-19

   1. Initial program 79.1%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in u around inf

      \[\leadsto \color{blue}{-1 \cdot \frac{t1 \cdot v}{{u}^{2}}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t1 \cdot v}{{u}^{2}}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{v \cdot t1}}{{u}^{2}}\right) \]

      3. unpow2 N/A

         \[\leadsto \mathsf{neg}\left(\frac{v \cdot t1}{\color{blue}{u \cdot u}}\right) \]

      4. times-frac N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{v}{u} \cdot \frac{t1}{u}}\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      7. distribute-frac-neg N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(v\right)}{u}} \cdot \frac{t1}{u} \]

      8. mul-1-neg N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot v}}{u} \cdot \frac{t1}{u} \]

      9. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot v}{u}} \cdot \frac{t1}{u} \]

      10. mul-1-neg N/A

          \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(v\right)}}{u} \cdot \frac{t1}{u} \]

      11. lower-neg.f64 N/A

          \[\leadsto \frac{\color{blue}{-v}}{u} \cdot \frac{t1}{u} \]

      12. lower-/.f64 84.5

          \[\leadsto \frac{-v}{u} \cdot \color{blue}{\frac{t1}{u}} \]

   5. Applied rewrites 84.5%

      \[\leadsto \color{blue}{\frac{-v}{u} \cdot \frac{t1}{u}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 83.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 8 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{u} \cdot \frac{-t1}{u}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 78.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 1.05 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\left(-v\right) \cdot \frac{\frac{t1}{u}}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -1.25e-70) (not (<= t1 1.05e-19)))
   (/ (* -1.0 v) (- t1 u))
   (* (- v) (/ (/ t1 u) u))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 1.05e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = -v * ((t1 / u) / u);
	}
	return tmp;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    real(8) :: tmp
    if ((t1 <= (-1.25d-70)) .or. (.not. (t1 <= 1.05d-19))) then
        tmp = ((-1.0d0) * v) / (t1 - u)
    else
        tmp = -v * ((t1 / u) / u)
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 1.05e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = -v * ((t1 / u) / u);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -1.25e-70) or not (t1 <= 1.05e-19):
		tmp = (-1.0 * v) / (t1 - u)
	else:
		tmp = -v * ((t1 / u) / u)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -1.25e-70) || !(t1 <= 1.05e-19))
		tmp = Float64(Float64(-1.0 * v) / Float64(t1 - u));
	else
		tmp = Float64(Float64(-v) * Float64(Float64(t1 / u) / u));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -1.25e-70) || ~((t1 <= 1.05e-19)))
		tmp = (-1.0 * v) / (t1 - u);
	else
		tmp = -v * ((t1 / u) / u);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.25e-70], N[Not[LessEqual[t1, 1.05e-19]], $MachinePrecision]], N[(N[(-1.0 * v), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision], N[((-v) * N[(N[(t1 / u), $MachinePrecision] / u), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t1 < -1.25e-70 or 1.0499999999999999e-19 < t1

   1. Initial program 69.9%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   4. Applied rewrites 99.6%

      \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

   5. Taylor expanded in u around 0

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   6. Step-by-step derivation

   7. Applied rewrites 82.6%

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   8. Step-by-step derivation

      1. lift--.f64 N/A

         \[\leadsto \frac{-1 \cdot \left(-v\right)}{\color{blue}{u - t1}} \]

      2. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-v\right)}{u - t1}} \]

      3. lift-*.f64 N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot \left(-v\right)}}{u - t1} \]

      4. *-commutative N/A

         \[\leadsto \frac{\color{blue}{\left(-v\right) \cdot -1}}{u - t1} \]

      5. associate-/l* N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

      8. lift--.f64 82.4

         \[\leadsto \left(-v\right) \cdot \frac{-1}{\color{blue}{u - t1}} \]

   9. Applied rewrites 82.4%

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]
   10. Step-by-step derivation

       1. lift-*.f64 N/A

          \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

       2. lift-/.f64 N/A

          \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

       3. associate-*r/ N/A

          \[\leadsto \color{blue}{\frac{\left(-v\right) \cdot -1}{u - t1}} \]

       4. frac-2neg N/A

          \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\left(u - t1\right)\right)}} \]

       5. lift--.f64 N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\left(u - t1\right)}\right)} \]

       6. flip-- N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\frac{u \cdot u - t1 \cdot t1}{u + t1}}\right)} \]

       7. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\frac{u \cdot u - t1 \cdot t1}{\color{blue}{t1 + u}}\right)} \]

       8. distribute-neg-frac N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\color{blue}{\frac{\mathsf{neg}\left(\left(u \cdot u - t1 \cdot t1\right)\right)}{t1 + u}}} \]

   11. Applied rewrites 82.6%

       \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1 - u}} \]

   if -1.25e-70 < t1 < 1.0499999999999999e-19

   1. Initial program 79.1%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in u around inf

      \[\leadsto \color{blue}{-1 \cdot \frac{t1 \cdot v}{{u}^{2}}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t1 \cdot v}{{u}^{2}}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{v \cdot t1}}{{u}^{2}}\right) \]

      3. unpow2 N/A

         \[\leadsto \mathsf{neg}\left(\frac{v \cdot t1}{\color{blue}{u \cdot u}}\right) \]

      4. times-frac N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{v}{u} \cdot \frac{t1}{u}}\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      7. distribute-frac-neg N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(v\right)}{u}} \cdot \frac{t1}{u} \]

      8. mul-1-neg N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot v}}{u} \cdot \frac{t1}{u} \]

      9. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot v}{u}} \cdot \frac{t1}{u} \]

      10. mul-1-neg N/A

          \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(v\right)}}{u} \cdot \frac{t1}{u} \]

      11. lower-neg.f64 N/A

          \[\leadsto \frac{\color{blue}{-v}}{u} \cdot \frac{t1}{u} \]

      12. lower-/.f64 84.5

          \[\leadsto \frac{-v}{u} \cdot \color{blue}{\frac{t1}{u}} \]

   5. Applied rewrites 84.5%

      \[\leadsto \color{blue}{\frac{-v}{u} \cdot \frac{t1}{u}} \]
   6. Step-by-step derivation

   7. Applied rewrites 81.1%

      \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{\frac{t1}{u}}{u}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 81.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 1.05 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\left(-v\right) \cdot \frac{\frac{t1}{u}}{u}\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 76.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 1.05 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\left(-t1\right) \cdot \frac{v}{u \cdot u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -1.25e-70) (not (<= t1 1.05e-19)))
   (/ (* -1.0 v) (- t1 u))
   (* (- t1) (/ v (* u u)))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 1.05e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = -t1 * (v / (u * u));
	}
	return tmp;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    real(8) :: tmp
    if ((t1 <= (-1.25d-70)) .or. (.not. (t1 <= 1.05d-19))) then
        tmp = ((-1.0d0) * v) / (t1 - u)
    else
        tmp = -t1 * (v / (u * u))
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.25e-70) || !(t1 <= 1.05e-19)) {
		tmp = (-1.0 * v) / (t1 - u);
	} else {
		tmp = -t1 * (v / (u * u));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -1.25e-70) or not (t1 <= 1.05e-19):
		tmp = (-1.0 * v) / (t1 - u)
	else:
		tmp = -t1 * (v / (u * u))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -1.25e-70) || !(t1 <= 1.05e-19))
		tmp = Float64(Float64(-1.0 * v) / Float64(t1 - u));
	else
		tmp = Float64(Float64(-t1) * Float64(v / Float64(u * u)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -1.25e-70) || ~((t1 <= 1.05e-19)))
		tmp = (-1.0 * v) / (t1 - u);
	else
		tmp = -t1 * (v / (u * u));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.25e-70], N[Not[LessEqual[t1, 1.05e-19]], $MachinePrecision]], N[(N[(-1.0 * v), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision], N[((-t1) * N[(v / N[(u * u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if t1 < -1.25e-70 or 1.0499999999999999e-19 < t1

   1. Initial program 69.9%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   4. Applied rewrites 99.6%

      \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

   5. Taylor expanded in u around 0

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   6. Step-by-step derivation

   7. Applied rewrites 82.6%

      \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
   8. Step-by-step derivation

      1. lift--.f64 N/A

         \[\leadsto \frac{-1 \cdot \left(-v\right)}{\color{blue}{u - t1}} \]

      2. lift-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot \left(-v\right)}{u - t1}} \]

      3. lift-*.f64 N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot \left(-v\right)}}{u - t1} \]

      4. *-commutative N/A

         \[\leadsto \frac{\color{blue}{\left(-v\right) \cdot -1}}{u - t1} \]

      5. associate-/l* N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

      7. lower-/.f64 N/A

         \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

      8. lift--.f64 82.4

         \[\leadsto \left(-v\right) \cdot \frac{-1}{\color{blue}{u - t1}} \]

   9. Applied rewrites 82.4%

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]
   10. Step-by-step derivation

       1. lift-*.f64 N/A

          \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

       2. lift-/.f64 N/A

          \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

       3. associate-*r/ N/A

          \[\leadsto \color{blue}{\frac{\left(-v\right) \cdot -1}{u - t1}} \]

       4. frac-2neg N/A

          \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\left(u - t1\right)\right)}} \]

       5. lift--.f64 N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\left(u - t1\right)}\right)} \]

       6. flip-- N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\frac{u \cdot u - t1 \cdot t1}{u + t1}}\right)} \]

       7. +-commutative N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\frac{u \cdot u - t1 \cdot t1}{\color{blue}{t1 + u}}\right)} \]

       8. distribute-neg-frac N/A

          \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\color{blue}{\frac{\mathsf{neg}\left(\left(u \cdot u - t1 \cdot t1\right)\right)}{t1 + u}}} \]

   11. Applied rewrites 82.6%

       \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1 - u}} \]

   if -1.25e-70 < t1 < 1.0499999999999999e-19

   1. Initial program 79.1%

      \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
   2. Add Preprocessing

   3. Taylor expanded in u around inf

      \[\leadsto \color{blue}{-1 \cdot \frac{t1 \cdot v}{{u}^{2}}} \]
   4. Step-by-step derivation

      1. mul-1-neg N/A

         \[\leadsto \color{blue}{\mathsf{neg}\left(\frac{t1 \cdot v}{{u}^{2}}\right)} \]

      2. *-commutative N/A

         \[\leadsto \mathsf{neg}\left(\frac{\color{blue}{v \cdot t1}}{{u}^{2}}\right) \]

      3. unpow2 N/A

         \[\leadsto \mathsf{neg}\left(\frac{v \cdot t1}{\color{blue}{u \cdot u}}\right) \]

      4. times-frac N/A

         \[\leadsto \mathsf{neg}\left(\color{blue}{\frac{v}{u} \cdot \frac{t1}{u}}\right) \]

      5. distribute-lft-neg-in N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      6. lower-*.f64 N/A

         \[\leadsto \color{blue}{\left(\mathsf{neg}\left(\frac{v}{u}\right)\right) \cdot \frac{t1}{u}} \]

      7. distribute-frac-neg N/A

         \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(v\right)}{u}} \cdot \frac{t1}{u} \]

      8. mul-1-neg N/A

         \[\leadsto \frac{\color{blue}{-1 \cdot v}}{u} \cdot \frac{t1}{u} \]

      9. lower-/.f64 N/A

         \[\leadsto \color{blue}{\frac{-1 \cdot v}{u}} \cdot \frac{t1}{u} \]

      10. mul-1-neg N/A

          \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(v\right)}}{u} \cdot \frac{t1}{u} \]

      11. lower-neg.f64 N/A

          \[\leadsto \frac{\color{blue}{-v}}{u} \cdot \frac{t1}{u} \]

      12. lower-/.f64 84.5

          \[\leadsto \frac{-v}{u} \cdot \color{blue}{\frac{t1}{u}} \]

   5. Applied rewrites 84.5%

      \[\leadsto \color{blue}{\frac{-v}{u} \cdot \frac{t1}{u}} \]

   6. Taylor expanded in u around 0

      \[\leadsto -1 \cdot \color{blue}{\frac{t1 \cdot v}{{u}^{2}}} \]
   7. Step-by-step derivation

   8. Applied rewrites 79.2%

      \[\leadsto \left(-t1\right) \cdot \color{blue}{\frac{v}{u \cdot u}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 81.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;t1 \leq -1.25 \cdot 10^{-70} \lor \neg \left(t1 \leq 1.05 \cdot 10^{-19}\right):\\ \;\;\;\;\frac{-1 \cdot v}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\left(-t1\right) \cdot \frac{v}{u \cdot u}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 60.9% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \frac{-1 \cdot v}{t1 - u} \end{array} \]

FPCore

(FPCore (u v t1) :precision binary64 (/ (* -1.0 v) (- t1 u)))

C

double code(double u, double v, double t1) {
	return (-1.0 * v) / (t1 - u);
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    code = ((-1.0d0) * v) / (t1 - u)
end function

Java

public static double code(double u, double v, double t1) {
	return (-1.0 * v) / (t1 - u);
}

Python

def code(u, v, t1):
	return (-1.0 * v) / (t1 - u)

Julia

function code(u, v, t1)
	return Float64(Float64(-1.0 * v) / Float64(t1 - u))
end

MATLAB

function tmp = code(u, v, t1)
	tmp = (-1.0 * v) / (t1 - u);
end

Wolfram

code[u_, v_, t1_] := N[(N[(-1.0 * v), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 73.9%

   \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
2. Add Preprocessing

4. Applied rewrites 97.2%

   \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

5. Taylor expanded in u around 0

   \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
6. Step-by-step derivation

7. Applied rewrites 62.0%

   \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
8. Step-by-step derivation

   1. lift--.f64 N/A

      \[\leadsto \frac{-1 \cdot \left(-v\right)}{\color{blue}{u - t1}} \]

   2. lift-/.f64 N/A

      \[\leadsto \color{blue}{\frac{-1 \cdot \left(-v\right)}{u - t1}} \]

   3. lift-*.f64 N/A

      \[\leadsto \frac{\color{blue}{-1 \cdot \left(-v\right)}}{u - t1} \]

   4. *-commutative N/A

      \[\leadsto \frac{\color{blue}{\left(-v\right) \cdot -1}}{u - t1} \]

   5. associate-/l* N/A

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

   6. lower-*.f64 N/A

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

   7. lower-/.f64 N/A

      \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

   8. lift--.f64 61.8

      \[\leadsto \left(-v\right) \cdot \frac{-1}{\color{blue}{u - t1}} \]

9. Applied rewrites 61.8%

   \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]
10. Step-by-step derivation

    1. lift-*.f64 N/A

       \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

    2. lift-/.f64 N/A

       \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

    3. associate-*r/ N/A

       \[\leadsto \color{blue}{\frac{\left(-v\right) \cdot -1}{u - t1}} \]

    4. frac-2neg N/A

       \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\left(u - t1\right)\right)}} \]

    5. lift--.f64 N/A

       \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\left(u - t1\right)}\right)} \]

    6. flip-- N/A

       \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\color{blue}{\frac{u \cdot u - t1 \cdot t1}{u + t1}}\right)} \]

    7. +-commutative N/A

       \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\mathsf{neg}\left(\frac{u \cdot u - t1 \cdot t1}{\color{blue}{t1 + u}}\right)} \]

    8. distribute-neg-frac N/A

       \[\leadsto \frac{\mathsf{neg}\left(\left(-v\right) \cdot -1\right)}{\color{blue}{\frac{\mathsf{neg}\left(\left(u \cdot u - t1 \cdot t1\right)\right)}{t1 + u}}} \]

11. Applied rewrites 62.0%

    \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1 - u}} \]
12. Add Preprocessing

Alternative 8: 60.8% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \frac{-1}{t1 - u} \cdot v \end{array} \]

FPCore

(FPCore (u v t1) :precision binary64 (* (/ -1.0 (- t1 u)) v))

C

double code(double u, double v, double t1) {
	return (-1.0 / (t1 - u)) * v;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    code = ((-1.0d0) / (t1 - u)) * v
end function

Java

public static double code(double u, double v, double t1) {
	return (-1.0 / (t1 - u)) * v;
}

Python

def code(u, v, t1):
	return (-1.0 / (t1 - u)) * v

Julia

function code(u, v, t1)
	return Float64(Float64(-1.0 / Float64(t1 - u)) * v)
end

MATLAB

function tmp = code(u, v, t1)
	tmp = (-1.0 / (t1 - u)) * v;
end

Wolfram

code[u_, v_, t1_] := N[(N[(-1.0 / N[(t1 - u), $MachinePrecision]), $MachinePrecision] * v), $MachinePrecision]

Derivation

1. Initial program 73.9%

   \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
2. Add Preprocessing

4. Applied rewrites 97.2%

   \[\leadsto \color{blue}{\frac{\frac{t1}{u - t1} \cdot \left(-v\right)}{u - t1}} \]

5. Taylor expanded in u around 0

   \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
6. Step-by-step derivation

7. Applied rewrites 62.0%

   \[\leadsto \frac{\color{blue}{-1} \cdot \left(-v\right)}{u - t1} \]
8. Step-by-step derivation

   1. lift--.f64 N/A

      \[\leadsto \frac{-1 \cdot \left(-v\right)}{\color{blue}{u - t1}} \]

   2. lift-/.f64 N/A

      \[\leadsto \color{blue}{\frac{-1 \cdot \left(-v\right)}{u - t1}} \]

   3. lift-*.f64 N/A

      \[\leadsto \frac{\color{blue}{-1 \cdot \left(-v\right)}}{u - t1} \]

   4. *-commutative N/A

      \[\leadsto \frac{\color{blue}{\left(-v\right) \cdot -1}}{u - t1} \]

   5. associate-/l* N/A

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

   6. lower-*.f64 N/A

      \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

   7. lower-/.f64 N/A

      \[\leadsto \left(-v\right) \cdot \color{blue}{\frac{-1}{u - t1}} \]

   8. lift--.f64 61.8

      \[\leadsto \left(-v\right) \cdot \frac{-1}{\color{blue}{u - t1}} \]

9. Applied rewrites 61.8%

   \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]
10. Step-by-step derivation

    1. lift-*.f64 N/A

       \[\leadsto \color{blue}{\left(-v\right) \cdot \frac{-1}{u - t1}} \]

    2. lift-neg.f64 N/A

       \[\leadsto \color{blue}{\left(\mathsf{neg}\left(v\right)\right)} \cdot \frac{-1}{u - t1} \]

    3. distribute-lft-neg-out N/A

       \[\leadsto \color{blue}{\mathsf{neg}\left(v \cdot \frac{-1}{u - t1}\right)} \]

    4. distribute-rgt-neg-in N/A

       \[\leadsto \color{blue}{v \cdot \left(\mathsf{neg}\left(\frac{-1}{u - t1}\right)\right)} \]

    5. lift-/.f64 N/A

       \[\leadsto v \cdot \left(\mathsf{neg}\left(\color{blue}{\frac{-1}{u - t1}}\right)\right) \]

    6. distribute-frac-neg N/A

       \[\leadsto v \cdot \color{blue}{\frac{\mathsf{neg}\left(-1\right)}{u - t1}} \]

    7. *-commutative N/A

       \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(-1\right)}{u - t1} \cdot v} \]

    8. lower-*.f64 N/A

       \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(-1\right)}{u - t1} \cdot v} \]

11. Applied rewrites 61.8%

    \[\leadsto \color{blue}{\frac{-1}{t1 - u} \cdot v} \]
12. Add Preprocessing

Alternative 9: 53.8% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \frac{-v}{t1} \end{array} \]

FPCore

(FPCore (u v t1) :precision binary64 (/ (- v) t1))

C

double code(double u, double v, double t1) {
	return -v / t1;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    code = -v / t1
end function

Java

public static double code(double u, double v, double t1) {
	return -v / t1;
}

Python

def code(u, v, t1):
	return -v / t1

Julia

function code(u, v, t1)
	return Float64(Float64(-v) / t1)
end

MATLAB

function tmp = code(u, v, t1)
	tmp = -v / t1;
end

Wolfram

code[u_, v_, t1_] := N[((-v) / t1), $MachinePrecision]

Derivation

1. Initial program 73.9%

   \[\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)} \]
2. Add Preprocessing

3. Taylor expanded in u around 0

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

   1. associate-*r/ N/A

      \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1}} \]

   2. lower-/.f64 N/A

      \[\leadsto \color{blue}{\frac{-1 \cdot v}{t1}} \]

   3. mul-1-neg N/A

      \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(v\right)}}{t1} \]

   4. lower-neg.f64 49.4

      \[\leadsto \frac{\color{blue}{-v}}{t1} \]

5. Applied rewrites 49.4%

   \[\leadsto \color{blue}{\frac{-v}{t1}} \]
6. Add Preprocessing

Reproduce

herbie shell --seed 2024343 
(FPCore (u v t1)
  :name "Rosa's DopplerBench"
  :precision binary64
  (/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))