Rosa's DopplerBench

Percentage Accurate: 72.6% → 98.3%

Time: 7.5s

Alternatives: 10

Speedup: 1.0×

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.6% 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: 98.3% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double u, double v, double t1) {
	return (-t1 / (t1 + u)) * (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 = (-t1 / (t1 + u)) * (v / (t1 + u))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 77.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -3.5 \cdot 10^{-97} \lor \neg \left(t1 \leq 1.4 \cdot 10^{+46}\right):\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{u} \cdot \frac{-v}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -3.5e-97) (not (<= t1 1.4e+46)))
   (/ v (- (* u -2.0) t1))
   (* (/ t1 u) (/ (- v) u))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -3.5e-97) || !(t1 <= 1.4e+46)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (t1 / u) * (-v / 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 <= (-3.5d-97)) .or. (.not. (t1 <= 1.4d+46))) then
        tmp = v / ((u * (-2.0d0)) - t1)
    else
        tmp = (t1 / u) * (-v / u)
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -3.5e-97) || !(t1 <= 1.4e+46)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (t1 / u) * (-v / u);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -3.5e-97) or not (t1 <= 1.4e+46):
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = (t1 / u) * (-v / u)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -3.5e-97) || !(t1 <= 1.4e+46))
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(Float64(t1 / u) * Float64(Float64(-v) / u));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -3.5e-97) || ~((t1 <= 1.4e+46)))
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = (t1 / u) * (-v / u);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -3.5e-97], N[Not[LessEqual[t1, 1.4e+46]], $MachinePrecision]], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(N[(t1 / u), $MachinePrecision] * N[((-v) / u), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 77.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -5 \cdot 10^{-95} \lor \neg \left(t1 \leq 1.4 \cdot 10^{+46}\right):\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{v \cdot \frac{t1}{u}}{-u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -5e-95) (not (<= t1 1.4e+46)))
   (/ v (- (* u -2.0) t1))
   (/ (* v (/ t1 u)) (- u))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -5e-95) || !(t1 <= 1.4e+46)) {
		tmp = v / ((u * -2.0) - t1);
	} 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 <= (-5d-95)) .or. (.not. (t1 <= 1.4d+46))) then
        tmp = v / ((u * (-2.0d0)) - t1)
    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 <= -5e-95) || !(t1 <= 1.4e+46)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (v * (t1 / u)) / -u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -5e-95) or not (t1 <= 1.4e+46):
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = (v * (t1 / u)) / -u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -5e-95) || !(t1 <= 1.4e+46))
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(Float64(v * Float64(t1 / u)) / Float64(-u));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -5e-95) || ~((t1 <= 1.4e+46)))
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = (v * (t1 / u)) / -u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -5e-95], N[Not[LessEqual[t1, 1.4e+46]], $MachinePrecision]], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(N[(v * N[(t1 / u), $MachinePrecision]), $MachinePrecision] / (-u)), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 76.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -4.1 \cdot 10^{-97} \lor \neg \left(t1 \leq 1.4 \cdot 10^{+46}\right):\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{t1 \cdot v}{u}}{-u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -4.1e-97) (not (<= t1 1.4e+46)))
   (/ v (- (* u -2.0) t1))
   (/ (/ (* t1 v) u) (- u))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -4.1e-97) || !(t1 <= 1.4e+46)) {
		tmp = v / ((u * -2.0) - t1);
	} 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 <= (-4.1d-97)) .or. (.not. (t1 <= 1.4d+46))) then
        tmp = v / ((u * (-2.0d0)) - t1)
    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 <= -4.1e-97) || !(t1 <= 1.4e+46)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = ((t1 * v) / u) / -u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -4.1e-97) or not (t1 <= 1.4e+46):
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = ((t1 * v) / u) / -u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -4.1e-97) || !(t1 <= 1.4e+46))
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(Float64(Float64(t1 * v) / u) / Float64(-u));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -4.1e-97) || ~((t1 <= 1.4e+46)))
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = ((t1 * v) / u) / -u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -4.1e-97], N[Not[LessEqual[t1, 1.4e+46]], $MachinePrecision]], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t1 * v), $MachinePrecision] / u), $MachinePrecision] / (-u)), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 68.8% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -3.7 \cdot 10^{+80} \lor \neg \left(u \leq 5.5 \cdot 10^{+87}\right):\\ \;\;\;\;\frac{t1}{\frac{u}{\frac{v}{u}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -3.7e+80) (not (<= u 5.5e+87)))
   (/ t1 (/ u (/ v u)))
   (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -3.7e+80) || !(u <= 5.5e+87)) {
		tmp = t1 / (u / (v / u));
	} 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) :: tmp
    if ((u <= (-3.7d+80)) .or. (.not. (u <= 5.5d+87))) then
        tmp = t1 / (u / (v / u))
    else
        tmp = -v / t1
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -3.7e+80) || !(u <= 5.5e+87)) {
		tmp = t1 / (u / (v / u));
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -3.7e+80) or not (u <= 5.5e+87):
		tmp = t1 / (u / (v / u))
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -3.7e+80) || !(u <= 5.5e+87))
		tmp = Float64(t1 / Float64(u / Float64(v / u)));
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -3.7e+80) || ~((u <= 5.5e+87)))
		tmp = t1 / (u / (v / u));
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -3.7e+80], N[Not[LessEqual[u, 5.5e+87]], $MachinePrecision]], N[(t1 / N[(u / N[(v / u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 66.4% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -1.4 \cdot 10^{+188}:\\ \;\;\;\;\frac{v}{u \cdot \frac{u}{t1}}\\ \mathbf{elif}\;u \leq 6 \cdot 10^{+241}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{\frac{u}{\frac{v}{u}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.4e+188)
   (/ v (* u (/ u t1)))
   (if (<= u 6e+241) (/ v (- (* u -2.0) t1)) (/ t1 (/ u (/ v u))))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.4e+188) {
		tmp = v / (u * (u / t1));
	} else if (u <= 6e+241) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = t1 / (u / (v / 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 (u <= (-1.4d+188)) then
        tmp = v / (u * (u / t1))
    else if (u <= 6d+241) then
        tmp = v / ((u * (-2.0d0)) - t1)
    else
        tmp = t1 / (u / (v / u))
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.4e+188) {
		tmp = v / (u * (u / t1));
	} else if (u <= 6e+241) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = t1 / (u / (v / u));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.4e+188:
		tmp = v / (u * (u / t1))
	elif u <= 6e+241:
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = t1 / (u / (v / u))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.4e+188)
		tmp = Float64(v / Float64(u * Float64(u / t1)));
	elseif (u <= 6e+241)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(t1 / Float64(u / Float64(v / u)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -1.4e+188)
		tmp = v / (u * (u / t1));
	elseif (u <= 6e+241)
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = t1 / (u / (v / u));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -1.4e+188], N[(v / N[(u * N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 6e+241], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(t1 / N[(u / N[(v / u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 56.9% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -2.9 \cdot 10^{+90} \lor \neg \left(u \leq 5.1 \cdot 10^{+244}\right):\\ \;\;\;\;\frac{v}{u} \cdot -0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -2.9e+90) (not (<= u 5.1e+244))) (* (/ v u) -0.5) (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -2.9e+90) || !(u <= 5.1e+244)) {
		tmp = (v / u) * -0.5;
	} 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) :: tmp
    if ((u <= (-2.9d+90)) .or. (.not. (u <= 5.1d+244))) then
        tmp = (v / u) * (-0.5d0)
    else
        tmp = -v / t1
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -2.9e+90) || !(u <= 5.1e+244)) {
		tmp = (v / u) * -0.5;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -2.9e+90) or not (u <= 5.1e+244):
		tmp = (v / u) * -0.5
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -2.9e+90) || !(u <= 5.1e+244))
		tmp = Float64(Float64(v / u) * -0.5);
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -2.9e+90) || ~((u <= 5.1e+244)))
		tmp = (v / u) * -0.5;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -2.9e+90], N[Not[LessEqual[u, 5.1e+244]], $MachinePrecision]], N[(N[(v / u), $MachinePrecision] * -0.5), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 57.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -3.1 \cdot 10^{+97} \lor \neg \left(u \leq 5.1 \cdot 10^{+244}\right):\\ \;\;\;\;\frac{v}{u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -3.1e+97) (not (<= u 5.1e+244))) (/ v u) (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -3.1e+97) || !(u <= 5.1e+244)) {
		tmp = v / u;
	} 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) :: tmp
    if ((u <= (-3.1d+97)) .or. (.not. (u <= 5.1d+244))) then
        tmp = v / u
    else
        tmp = -v / t1
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -3.1e+97) || !(u <= 5.1e+244)) {
		tmp = v / u;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -3.1e+97) or not (u <= 5.1e+244):
		tmp = v / u
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -3.1e+97) || !(u <= 5.1e+244))
		tmp = Float64(v / u);
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -3.1e+97) || ~((u <= 5.1e+244)))
		tmp = v / u;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -3.1e+97], N[Not[LessEqual[u, 5.1e+244]], $MachinePrecision]], N[(v / u), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 56.9% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -2.9 \cdot 10^{+90} \lor \neg \left(u \leq 5.1 \cdot 10^{+244}\right):\\ \;\;\;\;\frac{-v}{u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -2.9e+90) (not (<= u 5.1e+244))) (/ (- v) u) (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -2.9e+90) || !(u <= 5.1e+244)) {
		tmp = -v / u;
	} 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) :: tmp
    if ((u <= (-2.9d+90)) .or. (.not. (u <= 5.1d+244))) then
        tmp = -v / u
    else
        tmp = -v / t1
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -2.9e+90) || !(u <= 5.1e+244)) {
		tmp = -v / u;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -2.9e+90) or not (u <= 5.1e+244):
		tmp = -v / u
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -2.9e+90) || !(u <= 5.1e+244))
		tmp = Float64(Float64(-v) / u);
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -2.9e+90) || ~((u <= 5.1e+244)))
		tmp = -v / u;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -2.9e+90], N[Not[LessEqual[u, 5.1e+244]], $MachinePrecision]], N[((-v) / u), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 17.1% accurate, 4.0× speedup

Math

\[\begin{array}{l} \\ \frac{v}{u} \end{array} \]

FPCore

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

C

double code(double u, double v, double t1) {
	return v / 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 = v / u
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

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