Rosa's DopplerBench

Percentage Accurate: 72.8% → 98.2%

Time: 7.6s

Alternatives: 12

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.8% 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.2% 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: 78.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -7.8 \cdot 10^{-69} \lor \neg \left(t1 \leq 2.7 \cdot 10^{-131}\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 -7.8e-69) (not (<= t1 2.7e-131)))
   (/ v (- (* u -2.0) t1))
   (* (/ t1 u) (/ (- v) u))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -7.8e-69) || !(t1 <= 2.7e-131)) {
		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 <= (-7.8d-69)) .or. (.not. (t1 <= 2.7d-131))) 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 <= -7.8e-69) || !(t1 <= 2.7e-131)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (t1 / u) * (-v / u);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -7.8e-69) or not (t1 <= 2.7e-131):
		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 <= -7.8e-69) || !(t1 <= 2.7e-131))
		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 <= -7.8e-69) || ~((t1 <= 2.7e-131)))
		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, -7.8e-69], N[Not[LessEqual[t1, 2.7e-131]], $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: 79.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -8.5 \cdot 10^{-68} \lor \neg \left(t1 \leq 2.8 \cdot 10^{-132}\right):\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{t1}{u}}{\frac{-u}{v}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -8.5e-68) (not (<= t1 2.8e-132)))
   (/ v (- (* u -2.0) t1))
   (/ (/ t1 u) (/ (- u) v))))

C

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

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -8.5e-68) || !(t1 <= 2.8e-132)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (t1 / u) / (-u / v);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -8.5e-68) or not (t1 <= 2.8e-132):
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = (t1 / u) / (-u / v)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -8.5e-68) || !(t1 <= 2.8e-132))
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(Float64(t1 / u) / Float64(Float64(-u) / v));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -8.5e-68) || ~((t1 <= 2.8e-132)))
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = (t1 / u) / (-u / v);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -8.5e-68], N[Not[LessEqual[t1, 2.8e-132]], $MachinePrecision]], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(N[(t1 / u), $MachinePrecision] / N[((-u) / v), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 4: 59.4% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -1.65 \cdot 10^{+65} \lor \neg \left(u \leq 3.2 \cdot 10^{+183}\right):\\ \;\;\;\;t1 \cdot \frac{v}{t1 \cdot u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -1.65e+65) (not (<= u 3.2e+183)))
   (* t1 (/ v (* t1 u)))
   (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -1.65e+65) || !(u <= 3.2e+183)) {
		tmp = t1 * (v / (t1 * 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 <= (-1.65d+65)) .or. (.not. (u <= 3.2d+183))) then
        tmp = t1 * (v / (t1 * 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 <= -1.65e+65) || !(u <= 3.2e+183)) {
		tmp = t1 * (v / (t1 * u));
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -1.65e+65) or not (u <= 3.2e+183):
		tmp = t1 * (v / (t1 * u))
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -1.65e+65) || !(u <= 3.2e+183))
		tmp = Float64(t1 * Float64(v / Float64(t1 * u)));
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -1.65e+65) || ~((u <= 3.2e+183)))
		tmp = t1 * (v / (t1 * u));
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -1.65e+65], N[Not[LessEqual[u, 3.2e+183]], $MachinePrecision]], N[(t1 * N[(v / N[(t1 * u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 5: 67.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -3 \cdot 10^{+65} \lor \neg \left(u \leq 1.35 \cdot 10^{+153}\right):\\ \;\;\;\;\frac{v}{u \cdot \frac{u}{t1}}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -3e+65) (not (<= u 1.35e+153)))
   (/ v (* u (/ u t1)))
   (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -3e+65) || !(u <= 1.35e+153)) {
		tmp = v / (u * (u / t1));
	} 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 <= (-3d+65)) .or. (.not. (u <= 1.35d+153))) then
        tmp = v / (u * (u / t1))
    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 <= -3e+65) || !(u <= 1.35e+153)) {
		tmp = v / (u * (u / t1));
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -3e+65) or not (u <= 1.35e+153):
		tmp = v / (u * (u / t1))
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -3e+65) || !(u <= 1.35e+153))
		tmp = Float64(v / Float64(u * Float64(u / t1)));
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -3e+65) || ~((u <= 1.35e+153)))
		tmp = v / (u * (u / t1));
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -3e+65], N[Not[LessEqual[u, 1.35e+153]], $MachinePrecision]], N[(v / N[(u * N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 6: 68.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -8 \cdot 10^{+94} \lor \neg \left(u \leq 1.5 \cdot 10^{+155}\right):\\ \;\;\;\;\frac{v}{u \cdot \frac{u}{t1}}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -8e+94) (not (<= u 1.5e+155)))
   (/ v (* u (/ u t1)))
   (/ v (- (* u -2.0) t1))))

C

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

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -8e+94) || !(u <= 1.5e+155)) {
		tmp = v / (u * (u / t1));
	} else {
		tmp = v / ((u * -2.0) - t1);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -8e+94) or not (u <= 1.5e+155):
		tmp = v / (u * (u / t1))
	else:
		tmp = v / ((u * -2.0) - t1)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -8e+94) || !(u <= 1.5e+155))
		tmp = Float64(v / Float64(u * Float64(u / t1)));
	else
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -8e+94) || ~((u <= 1.5e+155)))
		tmp = v / (u * (u / t1));
	else
		tmp = v / ((u * -2.0) - t1);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -8e+94], N[Not[LessEqual[u, 1.5e+155]], $MachinePrecision]], N[(v / N[(u * N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 7: 59.4% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -3.2 \cdot 10^{+65}:\\ \;\;\;\;t1 \cdot \frac{v}{t1 \cdot u}\\ \mathbf{elif}\;u \leq 1.66 \cdot 10^{+184}:\\ \;\;\;\;\frac{-v}{t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{\frac{t1 \cdot u}{v}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -3.2e+65)
   (* t1 (/ v (* t1 u)))
   (if (<= u 1.66e+184) (/ (- v) t1) (/ t1 (/ (* t1 u) v)))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -3.2e+65) {
		tmp = t1 * (v / (t1 * u));
	} else if (u <= 1.66e+184) {
		tmp = -v / t1;
	} else {
		tmp = t1 / ((t1 * u) / v);
	}
	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.2d+65)) then
        tmp = t1 * (v / (t1 * u))
    else if (u <= 1.66d+184) then
        tmp = -v / t1
    else
        tmp = t1 / ((t1 * u) / v)
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if (u <= -3.2e+65) {
		tmp = t1 * (v / (t1 * u));
	} else if (u <= 1.66e+184) {
		tmp = -v / t1;
	} else {
		tmp = t1 / ((t1 * u) / v);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -3.2e+65:
		tmp = t1 * (v / (t1 * u))
	elif u <= 1.66e+184:
		tmp = -v / t1
	else:
		tmp = t1 / ((t1 * u) / v)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -3.2e+65)
		tmp = Float64(t1 * Float64(v / Float64(t1 * u)));
	elseif (u <= 1.66e+184)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = Float64(t1 / Float64(Float64(t1 * u) / v));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -3.2e+65)
		tmp = t1 * (v / (t1 * u));
	elseif (u <= 1.66e+184)
		tmp = -v / t1;
	else
		tmp = t1 / ((t1 * u) / v);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -3.2e+65], N[(t1 * N[(v / N[(t1 * u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.66e+184], N[((-v) / t1), $MachinePrecision], N[(t1 / N[(N[(t1 * u), $MachinePrecision] / v), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 8: 68.5% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -1.55 \cdot 10^{+95}:\\ \;\;\;\;\frac{t1 \cdot \frac{v}{u}}{u}\\ \mathbf{elif}\;u \leq 1.3 \cdot 10^{+153}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{u \cdot \frac{u}{t1}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.55e+95)
   (/ (* t1 (/ v u)) u)
   (if (<= u 1.3e+153) (/ v (- (* u -2.0) t1)) (/ v (* u (/ u t1))))))

C

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

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.55e+95) {
		tmp = (t1 * (v / u)) / u;
	} else if (u <= 1.3e+153) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = v / (u * (u / t1));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.55e+95:
		tmp = (t1 * (v / u)) / u
	elif u <= 1.3e+153:
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = v / (u * (u / t1))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.55e+95)
		tmp = Float64(Float64(t1 * Float64(v / u)) / u);
	elseif (u <= 1.3e+153)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(v / Float64(u * Float64(u / t1)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -1.55e+95)
		tmp = (t1 * (v / u)) / u;
	elseif (u <= 1.3e+153)
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = v / (u * (u / t1));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -1.55e+95], N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / u), $MachinePrecision], If[LessEqual[u, 1.3e+153], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(v / N[(u * N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 9: 23.6% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -6.8 \cdot 10^{+102} \lor \neg \left(t1 \leq 1.6 \cdot 10^{+84}\right):\\ \;\;\;\;\frac{v}{t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -6.8e+102) (not (<= t1 1.6e+84))) (/ v t1) (/ v u)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -6.8e+102) || !(t1 <= 1.6e+84)) {
		tmp = v / t1;
	} else {
		tmp = 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 <= (-6.8d+102)) .or. (.not. (t1 <= 1.6d+84))) then
        tmp = v / t1
    else
        tmp = v / u
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -6.8e+102) || !(t1 <= 1.6e+84)) {
		tmp = v / t1;
	} else {
		tmp = v / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -6.8e+102) or not (t1 <= 1.6e+84):
		tmp = v / t1
	else:
		tmp = v / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -6.8e+102) || !(t1 <= 1.6e+84))
		tmp = Float64(v / t1);
	else
		tmp = Float64(v / u);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -6.8e+102) || ~((t1 <= 1.6e+84)))
		tmp = v / t1;
	else
		tmp = v / u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -6.8e+102], N[Not[LessEqual[t1, 1.6e+84]], $MachinePrecision]], N[(v / t1), $MachinePrecision], N[(v / u), $MachinePrecision]]

Derivation

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

Alternative 10: 56.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq 9.2 \cdot 10^{+195}:\\ \;\;\;\;\frac{-v}{t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1) :precision binary64 (if (<= u 9.2e+195) (/ (- v) t1) (/ v u)))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= 9.2e+195) {
		tmp = -v / t1;
	} else {
		tmp = 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 <= 9.2d+195) then
        tmp = -v / t1
    else
        tmp = v / u
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if (u <= 9.2e+195) {
		tmp = -v / t1;
	} else {
		tmp = v / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= 9.2e+195:
		tmp = -v / t1
	else:
		tmp = v / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= 9.2e+195)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = Float64(v / u);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= 9.2e+195)
		tmp = -v / t1;
	else
		tmp = v / u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, 9.2e+195], N[((-v) / t1), $MachinePrecision], N[(v / u), $MachinePrecision]]

Derivation

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

Alternative 11: 56.3% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u 1.4e+196) (/ (- v) t1) (/ (- v) u)))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= 1.4e+196) {
		tmp = -v / t1;
	} else {
		tmp = -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+196) then
        tmp = -v / t1
    else
        tmp = -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+196) {
		tmp = -v / t1;
	} else {
		tmp = -v / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= 1.4e+196:
		tmp = -v / t1
	else:
		tmp = -v / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= 1.4e+196)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = Float64(Float64(-v) / u);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= 1.4e+196)
		tmp = -v / t1;
	else
		tmp = -v / u;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 12: 13.9% accurate, 4.0× 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(v / t1)
end

MATLAB

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

Wolfram

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

Derivation

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

Reproduce

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