Rosa's DopplerBench

Percentage Accurate: 73.7% → 97.9%

Time: 9.1s

Alternatives: 11

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: 73.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: 97.9% 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: 95.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -2.2 \cdot 10^{+116}:\\ \;\;\;\;\frac{t1 \cdot \frac{v}{u}}{t1 - u}\\ \mathbf{elif}\;u \leq 1.5 \cdot 10^{+186}:\\ \;\;\;\;\frac{v}{\left(t1 + u\right) \cdot \left(-1 - \frac{u}{t1}\right)}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{v}{u}}{\frac{t1 - u}{t1}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -2.2e+116)
   (/ (* t1 (/ v u)) (- t1 u))
   (if (<= u 1.5e+186)
     (/ v (* (+ t1 u) (- -1.0 (/ u t1))))
     (/ (/ v u) (/ (- t1 u) t1)))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -2.2e+116) {
		tmp = (t1 * (v / u)) / (t1 - u);
	} else if (u <= 1.5e+186) {
		tmp = v / ((t1 + u) * (-1.0 - (u / t1)));
	} else {
		tmp = (v / u) / ((t1 - 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 <= (-2.2d+116)) then
        tmp = (t1 * (v / u)) / (t1 - u)
    else if (u <= 1.5d+186) then
        tmp = v / ((t1 + u) * ((-1.0d0) - (u / t1)))
    else
        tmp = (v / u) / ((t1 - u) / t1)
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if (u <= -2.2e+116) {
		tmp = (t1 * (v / u)) / (t1 - u);
	} else if (u <= 1.5e+186) {
		tmp = v / ((t1 + u) * (-1.0 - (u / t1)));
	} else {
		tmp = (v / u) / ((t1 - u) / t1);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -2.2e+116:
		tmp = (t1 * (v / u)) / (t1 - u)
	elif u <= 1.5e+186:
		tmp = v / ((t1 + u) * (-1.0 - (u / t1)))
	else:
		tmp = (v / u) / ((t1 - u) / t1)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -2.2e+116)
		tmp = Float64(Float64(t1 * Float64(v / u)) / Float64(t1 - u));
	elseif (u <= 1.5e+186)
		tmp = Float64(v / Float64(Float64(t1 + u) * Float64(-1.0 - Float64(u / t1))));
	else
		tmp = Float64(Float64(v / u) / Float64(Float64(t1 - u) / t1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -2.2e+116)
		tmp = (t1 * (v / u)) / (t1 - u);
	elseif (u <= 1.5e+186)
		tmp = v / ((t1 + u) * (-1.0 - (u / t1)));
	else
		tmp = (v / u) / ((t1 - u) / t1);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -2.2e+116], N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.5e+186], N[(v / N[(N[(t1 + u), $MachinePrecision] * N[(-1.0 - N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(v / u), $MachinePrecision] / N[(N[(t1 - u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 3: 77.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -2.5 \cdot 10^{-16} \lor \neg \left(u \leq 3.05 \cdot 10^{+91}\right):\\ \;\;\;\;\frac{t1 \cdot \frac{v}{u}}{t1 - u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -2.5e-16) (not (<= u 3.05e+91)))
   (/ (* t1 (/ v u)) (- t1 u))
   (/ (- v) t1)))

C

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

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -2.5e-16) or not (u <= 3.05e+91):
		tmp = (t1 * (v / u)) / (t1 - u)
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -2.5e-16) || !(u <= 3.05e+91))
		tmp = Float64(Float64(t1 * Float64(v / u)) / 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 <= -2.5e-16) || ~((u <= 3.05e+91)))
		tmp = (t1 * (v / u)) / (t1 - u);
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -2.5e-16], N[Not[LessEqual[u, 3.05e+91]], $MachinePrecision]], N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 4: 76.3% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -1.35e-15) (not (<= u 2e+92)))
   (* (/ (- v) u) (/ t1 u))
   (/ (- v) t1)))

C

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

Python

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

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -1.35e-15) || !(u <= 2e+92))
		tmp = Float64(Float64(Float64(-v) / u) * 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.35e-15) || ~((u <= 2e+92)))
		tmp = (-v / u) * (t1 / u);
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 5: 76.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -3.5 \cdot 10^{-16}:\\ \;\;\;\;\frac{t1}{\frac{u}{v} \cdot \left(-u\right)}\\ \mathbf{elif}\;u \leq 1.8 \cdot 10^{+89}:\\ \;\;\;\;\frac{-v}{t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{u} \cdot \frac{t1}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -3.5e-16)
   (/ t1 (* (/ u v) (- u)))
   (if (<= u 1.8e+89) (/ (- v) t1) (* (/ (- v) u) (/ t1 u)))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -3.5e-16) {
		tmp = t1 / ((u / v) * -u);
	} else if (u <= 1.8e+89) {
		tmp = -v / t1;
	} 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 (u <= (-3.5d-16)) then
        tmp = t1 / ((u / v) * -u)
    else if (u <= 1.8d+89) then
        tmp = -v / t1
    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 (u <= -3.5e-16) {
		tmp = t1 / ((u / v) * -u);
	} else if (u <= 1.8e+89) {
		tmp = -v / t1;
	} else {
		tmp = (-v / u) * (t1 / u);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -3.5e-16:
		tmp = t1 / ((u / v) * -u)
	elif u <= 1.8e+89:
		tmp = -v / t1
	else:
		tmp = (-v / u) * (t1 / u)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -3.5e-16)
		tmp = Float64(t1 / Float64(Float64(u / v) * Float64(-u)));
	elseif (u <= 1.8e+89)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = Float64(Float64(Float64(-v) / u) * Float64(t1 / u));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -3.5e-16)
		tmp = t1 / ((u / v) * -u);
	elseif (u <= 1.8e+89)
		tmp = -v / t1;
	else
		tmp = (-v / u) * (t1 / u);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -3.5e-16], N[(t1 / N[(N[(u / v), $MachinePrecision] * (-u)), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.8e+89], N[((-v) / t1), $MachinePrecision], N[(N[((-v) / u), $MachinePrecision] * N[(t1 / u), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 6: 69.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -5.5 \cdot 10^{+52} \lor \neg \left(u \leq 1.25 \cdot 10^{+100}\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 -5.5e+52) (not (<= u 1.25e+100)))
   (/ t1 (/ u (/ v u)))
   (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -5.5e+52) || !(u <= 1.25e+100)) {
		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 <= (-5.5d+52)) .or. (.not. (u <= 1.25d+100))) 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 <= -5.5e+52) || !(u <= 1.25e+100)) {
		tmp = t1 / (u / (v / u));
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -5.5e+52) or not (u <= 1.25e+100):
		tmp = t1 / (u / (v / u))
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -5.5e+52) || !(u <= 1.25e+100))
		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 <= -5.5e+52) || ~((u <= 1.25e+100)))
		tmp = t1 / (u / (v / u));
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 7: 23.0% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -1.7 \cdot 10^{+23} \lor \neg \left(t1 \leq 2.6 \cdot 10^{+122}\right):\\ \;\;\;\;\frac{v}{t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -1.7e+23) (not (<= t1 2.6e+122))) (/ v t1) (/ v u)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.7e+23) || !(t1 <= 2.6e+122)) {
		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 <= (-1.7d+23)) .or. (.not. (t1 <= 2.6d+122))) 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 <= -1.7e+23) || !(t1 <= 2.6e+122)) {
		tmp = v / t1;
	} else {
		tmp = v / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -1.7e+23) or not (t1 <= 2.6e+122):
		tmp = v / t1
	else:
		tmp = v / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -1.7e+23) || !(t1 <= 2.6e+122))
		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 <= -1.7e+23) || ~((t1 <= 2.6e+122)))
		tmp = v / t1;
	else
		tmp = v / u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.7e+23], N[Not[LessEqual[t1, 2.6e+122]], $MachinePrecision]], N[(v / t1), $MachinePrecision], N[(v / u), $MachinePrecision]]

Derivation

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

Alternative 8: 56.3% accurate, 1.7× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.04e+192) (* (/ v u) -0.5) (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.04e+192) {
		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 <= (-1.04d+192)) 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 <= -1.04e+192) {
		tmp = (v / u) * -0.5;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.04e+192:
		tmp = (v / u) * -0.5
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.04e+192)
		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 <= -1.04e+192)
		tmp = (v / u) * -0.5;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -1.04e+192], N[(N[(v / u), $MachinePrecision] * -0.5), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 9: 56.2% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -9.8e+191)
		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 <= -9.8e+191)
		tmp = v / u;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -9.8e+191], N[(v / u), $MachinePrecision], N[((-v) / t1), $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 -2.5 \cdot 10^{+192}:\\ \;\;\;\;\frac{-v}{u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

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

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -2.5e+192) {
		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.5d+192)) 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.5e+192) {
		tmp = -v / u;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

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

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -2.5e+192)
		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.5e+192)
		tmp = -v / u;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 11: 14.0% 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 2023343 
(FPCore (u v t1)
  :name "Rosa's DopplerBench"
  :precision binary64
  (/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))