Rosa's DopplerBench

Percentage Accurate: 72.8% → 98.2%

Time: 9.6s

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.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: 83.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := v \cdot \frac{-t1}{\left(t1 + u\right) \cdot \left(t1 + u\right)}\\ \mathbf{if}\;u \leq -8.5 \cdot 10^{-109}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;u \leq 1.45 \cdot 10^{-160}:\\ \;\;\;\;\frac{-v}{t1 + u \cdot 2}\\ \mathbf{elif}\;u \leq 1.95 \cdot 10^{+73}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{\left(-t1\right) \cdot \frac{v}{t1 + u}}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (let* ((t_1 (* v (/ (- t1) (* (+ t1 u) (+ t1 u))))))
   (if (<= u -8.5e-109)
     t_1
     (if (<= u 1.45e-160)
       (/ (- v) (+ t1 (* u 2.0)))
       (if (<= u 1.95e+73) t_1 (/ (* (- t1) (/ v (+ t1 u))) u))))))

C

double code(double u, double v, double t1) {
	double t_1 = v * (-t1 / ((t1 + u) * (t1 + u)));
	double tmp;
	if (u <= -8.5e-109) {
		tmp = t_1;
	} else if (u <= 1.45e-160) {
		tmp = -v / (t1 + (u * 2.0));
	} else if (u <= 1.95e+73) {
		tmp = t_1;
	} else {
		tmp = (-t1 * (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) :: t_1
    real(8) :: tmp
    t_1 = v * (-t1 / ((t1 + u) * (t1 + u)))
    if (u <= (-8.5d-109)) then
        tmp = t_1
    else if (u <= 1.45d-160) then
        tmp = -v / (t1 + (u * 2.0d0))
    else if (u <= 1.95d+73) then
        tmp = t_1
    else
        tmp = (-t1 * (v / (t1 + u))) / u
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double t_1 = v * (-t1 / ((t1 + u) * (t1 + u)));
	double tmp;
	if (u <= -8.5e-109) {
		tmp = t_1;
	} else if (u <= 1.45e-160) {
		tmp = -v / (t1 + (u * 2.0));
	} else if (u <= 1.95e+73) {
		tmp = t_1;
	} else {
		tmp = (-t1 * (v / (t1 + u))) / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	t_1 = v * (-t1 / ((t1 + u) * (t1 + u)))
	tmp = 0
	if u <= -8.5e-109:
		tmp = t_1
	elif u <= 1.45e-160:
		tmp = -v / (t1 + (u * 2.0))
	elif u <= 1.95e+73:
		tmp = t_1
	else:
		tmp = (-t1 * (v / (t1 + u))) / u
	return tmp

Julia

function code(u, v, t1)
	t_1 = Float64(v * Float64(Float64(-t1) / Float64(Float64(t1 + u) * Float64(t1 + u))))
	tmp = 0.0
	if (u <= -8.5e-109)
		tmp = t_1;
	elseif (u <= 1.45e-160)
		tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * 2.0)));
	elseif (u <= 1.95e+73)
		tmp = t_1;
	else
		tmp = Float64(Float64(Float64(-t1) * Float64(v / Float64(t1 + u))) / u);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	t_1 = v * (-t1 / ((t1 + u) * (t1 + u)));
	tmp = 0.0;
	if (u <= -8.5e-109)
		tmp = t_1;
	elseif (u <= 1.45e-160)
		tmp = -v / (t1 + (u * 2.0));
	elseif (u <= 1.95e+73)
		tmp = t_1;
	else
		tmp = (-t1 * (v / (t1 + u))) / u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := Block[{t$95$1 = N[(v * N[((-t1) / N[(N[(t1 + u), $MachinePrecision] * N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -8.5e-109], t$95$1, If[LessEqual[u, 1.45e-160], N[((-v) / N[(t1 + N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.95e+73], t$95$1, N[(N[((-t1) * N[(v / N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / u), $MachinePrecision]]]]]

Derivation

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

Alternative 3: 78.9% accurate, 0.7× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -1.45e-69) (not (<= t1 2.7e-131)))
   (/ (- v) (+ t1 (* u 2.0)))
   (* (/ t1 u) (/ (- v) u))))

C

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

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -1.45e-69) or not (t1 <= 2.7e-131):
		tmp = -v / (t1 + (u * 2.0))
	else:
		tmp = (t1 / u) * (-v / u)
	return tmp

Julia

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

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.45e-69], N[Not[LessEqual[t1, 2.7e-131]], $MachinePrecision]], N[((-v) / N[(t1 + N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t1 / u), $MachinePrecision] * N[((-v) / u), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 4: 78.5% accurate, 0.7× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= t1 -3.1e-65)
   (/ (- v) (- t1 u))
   (if (<= t1 2.7e-131) (* (/ t1 u) (/ (- v) u)) (/ -1.0 (/ (+ t1 u) v)))))

C

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

Java

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

Python

def code(u, v, t1):
	tmp = 0
	if t1 <= -3.1e-65:
		tmp = -v / (t1 - u)
	elif t1 <= 2.7e-131:
		tmp = (t1 / u) * (-v / u)
	else:
		tmp = -1.0 / ((t1 + u) / v)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (t1 <= -3.1e-65)
		tmp = Float64(Float64(-v) / Float64(t1 - u));
	elseif (t1 <= 2.7e-131)
		tmp = Float64(Float64(t1 / u) * Float64(Float64(-v) / u));
	else
		tmp = Float64(-1.0 / Float64(Float64(t1 + u) / v));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (t1 <= -3.1e-65)
		tmp = -v / (t1 - u);
	elseif (t1 <= 2.7e-131)
		tmp = (t1 / u) * (-v / u);
	else
		tmp = -1.0 / ((t1 + u) / v);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 5: 58.2% accurate, 0.8× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -3.2e+65) || !(u <= 4e+152))
		tmp = 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 <= -3.2e+65) || ~((u <= 4e+152)))
		tmp = v / (t1 + u);
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 6: 23.2% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -3.7e+108) (not (<= t1 5.2e+76))) (/ v t1) (/ (- v) u)))

C

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

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -3.7e+108) or not (t1 <= 5.2e+76):
		tmp = v / t1
	else:
		tmp = -v / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -3.7e+108) || !(t1 <= 5.2e+76))
		tmp = 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 ((t1 <= -3.7e+108) || ~((t1 <= 5.2e+76)))
		tmp = v / t1;
	else
		tmp = -v / u;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 7: 23.6% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -1.4e+102) (not (<= t1 2.3e+82))) (/ v t1) (/ v u)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -1.4e+102) || !(t1 <= 2.3e+82)) {
		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.4d+102)) .or. (.not. (t1 <= 2.3d+82))) 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.4e+102) || !(t1 <= 2.3e+82)) {
		tmp = v / t1;
	} else {
		tmp = v / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -1.4e+102) or not (t1 <= 2.3e+82):
		tmp = v / t1
	else:
		tmp = v / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -1.4e+102) || !(t1 <= 2.3e+82))
		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.4e+102) || ~((t1 <= 2.3e+82)))
		tmp = v / t1;
	else
		tmp = v / u;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 8: 56.3% accurate, 1.3× speedup

Math

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

FPCore

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

C

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

Python

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

Julia

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

Wolfram

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

Derivation

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

Alternative 9: 61.5% accurate, 2.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 10: 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))))