Rosa's DopplerBench

Percentage Accurate: 72.4% → 97.8%

Time: 9.0s

Alternatives: 14

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.4% 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.8% 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.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -1.75 \cdot 10^{-63}:\\ \;\;\;\;\frac{\frac{v}{t1 + u}}{\frac{-u}{t1}}\\ \mathbf{elif}\;u \leq 3.75 \cdot 10^{-6}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{\frac{t1 + u}{v} \cdot \left(t1 - u\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.75e-63)
   (/ (/ v (+ t1 u)) (/ (- u) t1))
   (if (<= u 3.75e-6)
     (/ v (- (* u -2.0) t1))
     (/ t1 (* (/ (+ t1 u) v) (- t1 u))))))

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 3: 95.6% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.7e+159)
   (/ (* t1 (/ v u)) (- u))
   (/ v (* (+ t1 u) (- -1.0 (/ u t1))))))

C

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

Java

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

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.7e+159:
		tmp = (t1 * (v / u)) / -u
	else:
		tmp = v / ((t1 + u) * (-1.0 - (u / t1)))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.7e+159)
		tmp = Float64(Float64(t1 * Float64(v / u)) / Float64(-u));
	else
		tmp = Float64(v / Float64(Float64(t1 + u) * Float64(-1.0 - Float64(u / t1))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -1.7e+159)
		tmp = (t1 * (v / u)) / -u;
	else
		tmp = v / ((t1 + u) * (-1.0 - (u / t1)));
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 4: 75.6% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -3.6e-58) (not (<= u 1.06e+29)))
   (* (/ v u) (/ (- t1) u))
   (/ v (- (* u -2.0) t1))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -3.6e-58) || !(u <= 1.06e+29)) {
		tmp = (v / u) * (-t1 / u);
	} 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 <= (-3.6d-58)) .or. (.not. (u <= 1.06d+29))) then
        tmp = (v / u) * (-t1 / u)
    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 <= -3.6e-58) || !(u <= 1.06e+29)) {
		tmp = (v / u) * (-t1 / u);
	} else {
		tmp = v / ((u * -2.0) - t1);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -3.6e-58) or not (u <= 1.06e+29):
		tmp = (v / u) * (-t1 / u)
	else:
		tmp = v / ((u * -2.0) - t1)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -3.6e-58) || !(u <= 1.06e+29))
		tmp = Float64(Float64(v / u) * Float64(Float64(-t1) / u));
	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 <= -3.6e-58) || ~((u <= 1.06e+29)))
		tmp = (v / u) * (-t1 / u);
	else
		tmp = v / ((u * -2.0) - t1);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -3.6e-58], N[Not[LessEqual[u, 1.06e+29]], $MachinePrecision]], N[(N[(v / u), $MachinePrecision] * N[((-t1) / u), $MachinePrecision]), $MachinePrecision], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 5: 75.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -6.5 \cdot 10^{-58}:\\ \;\;\;\;\frac{v}{u} \cdot \frac{-t1}{u}\\ \mathbf{elif}\;u \leq 9.5 \cdot 10^{+28}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{u \cdot \frac{-u}{v}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -6.5e-58)
   (* (/ v u) (/ (- t1) u))
   (if (<= u 9.5e+28) (/ v (- (* u -2.0) t1)) (/ t1 (* u (/ (- u) v))))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -6.5e-58) {
		tmp = (v / u) * (-t1 / u);
	} else if (u <= 9.5e+28) {
		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 (u <= (-6.5d-58)) then
        tmp = (v / u) * (-t1 / u)
    else if (u <= 9.5d+28) 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 (u <= -6.5e-58) {
		tmp = (v / u) * (-t1 / u);
	} else if (u <= 9.5e+28) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = t1 / (u * (-u / v));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -6.5e-58:
		tmp = (v / u) * (-t1 / u)
	elif u <= 9.5e+28:
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = t1 / (u * (-u / v))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -6.5e-58)
		tmp = Float64(Float64(v / u) * Float64(Float64(-t1) / u));
	elseif (u <= 9.5e+28)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(t1 / Float64(u * Float64(Float64(-u) / v)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -6.5e-58)
		tmp = (v / u) * (-t1 / u);
	elseif (u <= 9.5e+28)
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = t1 / (u * (-u / v));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -6.5e-58], N[(N[(v / u), $MachinePrecision] * N[((-t1) / u), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 9.5e+28], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(t1 / N[(u * N[((-u) / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 6: 76.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -1.22 \cdot 10^{-57}:\\ \;\;\;\;\frac{t1 \cdot \frac{v}{u}}{-u}\\ \mathbf{elif}\;u \leq 9.5 \cdot 10^{+28}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{u \cdot \frac{-u}{v}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.22e-57)
   (/ (* t1 (/ v u)) (- u))
   (if (<= u 9.5e+28) (/ v (- (* u -2.0) t1)) (/ t1 (* u (/ (- u) v))))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.22e-57) {
		tmp = (t1 * (v / u)) / -u;
	} else if (u <= 9.5e+28) {
		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 (u <= (-1.22d-57)) then
        tmp = (t1 * (v / u)) / -u
    else if (u <= 9.5d+28) 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 (u <= -1.22e-57) {
		tmp = (t1 * (v / u)) / -u;
	} else if (u <= 9.5e+28) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = t1 / (u * (-u / v));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.22e-57:
		tmp = (t1 * (v / u)) / -u
	elif u <= 9.5e+28:
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = t1 / (u * (-u / v))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.22e-57)
		tmp = Float64(Float64(t1 * Float64(v / u)) / Float64(-u));
	elseif (u <= 9.5e+28)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(t1 / Float64(u * Float64(Float64(-u) / v)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -1.22e-57)
		tmp = (t1 * (v / u)) / -u;
	elseif (u <= 9.5e+28)
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = t1 / (u * (-u / v));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -1.22e-57], N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / (-u)), $MachinePrecision], If[LessEqual[u, 9.5e+28], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(t1 / N[(u * N[((-u) / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 7: 77.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -1.35 \cdot 10^{-63}:\\ \;\;\;\;\frac{\frac{v}{t1 + u}}{\frac{-u}{t1}}\\ \mathbf{elif}\;u \leq 1.1 \cdot 10^{+29}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{u \cdot \frac{-u}{v}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.35e-63)
   (/ (/ v (+ t1 u)) (/ (- u) t1))
   (if (<= u 1.1e+29) (/ v (- (* u -2.0) t1)) (/ t1 (* u (/ (- u) v))))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.35e-63) {
		tmp = (v / (t1 + u)) / (-u / t1);
	} else if (u <= 1.1e+29) {
		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 (u <= (-1.35d-63)) then
        tmp = (v / (t1 + u)) / (-u / t1)
    else if (u <= 1.1d+29) 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 (u <= -1.35e-63) {
		tmp = (v / (t1 + u)) / (-u / t1);
	} else if (u <= 1.1e+29) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = t1 / (u * (-u / v));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.35e-63:
		tmp = (v / (t1 + u)) / (-u / t1)
	elif u <= 1.1e+29:
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = t1 / (u * (-u / v))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.35e-63)
		tmp = Float64(Float64(v / Float64(t1 + u)) / Float64(Float64(-u) / t1));
	elseif (u <= 1.1e+29)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(t1 / Float64(u * Float64(Float64(-u) / v)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -1.35e-63)
		tmp = (v / (t1 + u)) / (-u / t1);
	elseif (u <= 1.1e+29)
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = t1 / (u * (-u / v));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -1.35e-63], N[(N[(v / N[(t1 + u), $MachinePrecision]), $MachinePrecision] / N[((-u) / t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.1e+29], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(t1 / N[(u * N[((-u) / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 8: 69.0% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -1.25e+91) (not (<= u 1.05e+29)))
   (/ t1 (* u (/ u v)))
   (/ (- v) t1)))

C

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 9: 68.3% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.15e+92)
   (/ v (* u (/ u t1)))
   (if (<= u 1e+29) (/ (- v) t1) (/ t1 (* u (/ u v))))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.15e+92) {
		tmp = v / (u * (u / t1));
	} else if (u <= 1e+29) {
		tmp = -v / 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 (u <= (-1.15d+92)) then
        tmp = v / (u * (u / t1))
    else if (u <= 1d+29) then
        tmp = -v / 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 (u <= -1.15e+92) {
		tmp = v / (u * (u / t1));
	} else if (u <= 1e+29) {
		tmp = -v / t1;
	} else {
		tmp = t1 / (u * (u / v));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.15e+92:
		tmp = v / (u * (u / t1))
	elif u <= 1e+29:
		tmp = -v / t1
	else:
		tmp = t1 / (u * (u / v))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.15e+92)
		tmp = Float64(v / Float64(u * Float64(u / t1)));
	elseif (u <= 1e+29)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = Float64(t1 / Float64(u * Float64(u / v)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -1.15e+92)
		tmp = v / (u * (u / t1));
	elseif (u <= 1e+29)
		tmp = -v / t1;
	else
		tmp = t1 / (u * (u / v));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -1.15e+92], N[(v / N[(u * N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1e+29], N[((-v) / t1), $MachinePrecision], N[(t1 / N[(u * N[(u / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 10: 68.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -1.6 \cdot 10^{+121}:\\ \;\;\;\;\frac{v}{u \cdot \frac{u}{t1}}\\ \mathbf{elif}\;u \leq 1.16 \cdot 10^{+29}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1}{u \cdot \frac{u}{v}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -1.6e+121)
   (/ v (* u (/ u t1)))
   (if (<= u 1.16e+29) (/ v (- (* u -2.0) t1)) (/ t1 (* u (/ u v))))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -1.6e+121) {
		tmp = v / (u * (u / t1));
	} else if (u <= 1.16e+29) {
		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 (u <= (-1.6d+121)) then
        tmp = v / (u * (u / t1))
    else if (u <= 1.16d+29) 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 (u <= -1.6e+121) {
		tmp = v / (u * (u / t1));
	} else if (u <= 1.16e+29) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = t1 / (u * (u / v));
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -1.6e+121:
		tmp = v / (u * (u / t1))
	elif u <= 1.16e+29:
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = t1 / (u * (u / v))
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -1.6e+121)
		tmp = Float64(v / Float64(u * Float64(u / t1)));
	elseif (u <= 1.16e+29)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(t1 / Float64(u * Float64(u / v)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -1.6e+121)
		tmp = v / (u * (u / t1));
	elseif (u <= 1.16e+29)
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = t1 / (u * (u / v));
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -1.6e+121], N[(v / N[(u * N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.16e+29], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(t1 / N[(u * N[(u / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 11: 59.9% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -4.1 \cdot 10^{+130} \lor \neg \left(u \leq 4.2 \cdot 10^{+150}\right):\\ \;\;\;\;\frac{-1}{\frac{u}{v}}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -4.1e+130) (not (<= u 4.2e+150)))
   (/ -1.0 (/ u v))
   (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -4.1e+130) || !(u <= 4.2e+150)) {
		tmp = -1.0 / (u / v);
	} 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 <= (-4.1d+130)) .or. (.not. (u <= 4.2d+150))) then
        tmp = (-1.0d0) / (u / v)
    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 <= -4.1e+130) || !(u <= 4.2e+150)) {
		tmp = -1.0 / (u / v);
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -4.1e+130) or not (u <= 4.2e+150):
		tmp = -1.0 / (u / v)
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -4.1e+130) || !(u <= 4.2e+150))
		tmp = Float64(-1.0 / Float64(u / v));
	else
		tmp = Float64(Float64(-v) / t1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((u <= -4.1e+130) || ~((u <= 4.2e+150)))
		tmp = -1.0 / (u / v);
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -4.1e+130], N[Not[LessEqual[u, 4.2e+150]], $MachinePrecision]], N[(-1.0 / N[(u / v), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 12: 59.4% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -2.7 \cdot 10^{+91}:\\ \;\;\;\;\frac{1}{\frac{u}{v}}\\ \mathbf{elif}\;u \leq 1.55 \cdot 10^{+150}:\\ \;\;\;\;\frac{-v}{t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{-1}{\frac{u}{v}}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -2.7e+91)
   (/ 1.0 (/ u v))
   (if (<= u 1.55e+150) (/ (- v) t1) (/ -1.0 (/ u v)))))

C

double code(double u, double v, double t1) {
	double tmp;
	if (u <= -2.7e+91) {
		tmp = 1.0 / (u / v);
	} else if (u <= 1.55e+150) {
		tmp = -v / t1;
	} else {
		tmp = -1.0 / (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 <= (-2.7d+91)) then
        tmp = 1.0d0 / (u / v)
    else if (u <= 1.55d+150) then
        tmp = -v / t1
    else
        tmp = (-1.0d0) / (u / v)
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if (u <= -2.7e+91) {
		tmp = 1.0 / (u / v);
	} else if (u <= 1.55e+150) {
		tmp = -v / t1;
	} else {
		tmp = -1.0 / (u / v);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -2.7e+91:
		tmp = 1.0 / (u / v)
	elif u <= 1.55e+150:
		tmp = -v / t1
	else:
		tmp = -1.0 / (u / v)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -2.7e+91)
		tmp = Float64(1.0 / Float64(u / v));
	elseif (u <= 1.55e+150)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = Float64(-1.0 / Float64(u / v));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -2.7e+91)
		tmp = 1.0 / (u / v);
	elseif (u <= 1.55e+150)
		tmp = -v / t1;
	else
		tmp = -1.0 / (u / v);
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[LessEqual[u, -2.7e+91], N[(1.0 / N[(u / v), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.55e+150], N[((-v) / t1), $MachinePrecision], N[(-1.0 / N[(u / v), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 13: 59.7% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -7.8 \cdot 10^{+130} \lor \neg \left(u \leq 4.9 \cdot 10^{+149}\right):\\ \;\;\;\;\frac{-v}{u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -7.8e+130) (not (<= u 4.9e+149))) (/ (- v) u) (/ (- v) t1)))

C

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

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -7.8e+130) or not (u <= 4.9e+149):
		tmp = -v / u
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -7.8e+130) || !(u <= 4.9e+149))
		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 <= -7.8e+130) || ~((u <= 4.9e+149)))
		tmp = -v / u;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -7.8e+130], N[Not[LessEqual[u, 4.9e+149]], $MachinePrecision]], N[((-v) / u), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 14: 55.3% accurate, 3.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(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 2023348 
(FPCore (u v t1)
  :name "Rosa's DopplerBench"
  :precision binary64
  (/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))