Rosa's DopplerBench

Percentage Accurate: 72.0% → 98.0%

Time: 9.1s

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.0% 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.0% 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: 79.0% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t1 \cdot \frac{v}{t1 - u}}{u}\\ \mathbf{if}\;u \leq -3.2 \cdot 10^{-53}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;u \leq 4.6 \cdot 10^{-88}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{elif}\;u \leq 3 \cdot 10^{-9}:\\ \;\;\;\;t1 \cdot \frac{\frac{v}{u}}{t1 - u}\\ \mathbf{elif}\;u \leq 1.5 \cdot 10^{+15}:\\ \;\;\;\;\frac{-v}{t1}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (let* ((t_1 (/ (* t1 (/ v (- t1 u))) u)))
   (if (<= u -3.2e-53)
     t_1
     (if (<= u 4.6e-88)
       (/ v (- (* u -2.0) t1))
       (if (<= u 3e-9)
         (* t1 (/ (/ v u) (- t1 u)))
         (if (<= u 1.5e+15) (/ (- v) t1) t_1))))))

C

double code(double u, double v, double t1) {
	double t_1 = (t1 * (v / (t1 - u))) / u;
	double tmp;
	if (u <= -3.2e-53) {
		tmp = t_1;
	} else if (u <= 4.6e-88) {
		tmp = v / ((u * -2.0) - t1);
	} else if (u <= 3e-9) {
		tmp = t1 * ((v / u) / (t1 - u));
	} else if (u <= 1.5e+15) {
		tmp = -v / t1;
	} else {
		tmp = t_1;
	}
	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 = (t1 * (v / (t1 - u))) / u
    if (u <= (-3.2d-53)) then
        tmp = t_1
    else if (u <= 4.6d-88) then
        tmp = v / ((u * (-2.0d0)) - t1)
    else if (u <= 3d-9) then
        tmp = t1 * ((v / u) / (t1 - u))
    else if (u <= 1.5d+15) then
        tmp = -v / t1
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double t_1 = (t1 * (v / (t1 - u))) / u;
	double tmp;
	if (u <= -3.2e-53) {
		tmp = t_1;
	} else if (u <= 4.6e-88) {
		tmp = v / ((u * -2.0) - t1);
	} else if (u <= 3e-9) {
		tmp = t1 * ((v / u) / (t1 - u));
	} else if (u <= 1.5e+15) {
		tmp = -v / t1;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	t_1 = (t1 * (v / (t1 - u))) / u
	tmp = 0
	if u <= -3.2e-53:
		tmp = t_1
	elif u <= 4.6e-88:
		tmp = v / ((u * -2.0) - t1)
	elif u <= 3e-9:
		tmp = t1 * ((v / u) / (t1 - u))
	elif u <= 1.5e+15:
		tmp = -v / t1
	else:
		tmp = t_1
	return tmp

Julia

function code(u, v, t1)
	t_1 = Float64(Float64(t1 * Float64(v / Float64(t1 - u))) / u)
	tmp = 0.0
	if (u <= -3.2e-53)
		tmp = t_1;
	elseif (u <= 4.6e-88)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	elseif (u <= 3e-9)
		tmp = Float64(t1 * Float64(Float64(v / u) / Float64(t1 - u)));
	elseif (u <= 1.5e+15)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	t_1 = (t1 * (v / (t1 - u))) / u;
	tmp = 0.0;
	if (u <= -3.2e-53)
		tmp = t_1;
	elseif (u <= 4.6e-88)
		tmp = v / ((u * -2.0) - t1);
	elseif (u <= 3e-9)
		tmp = t1 * ((v / u) / (t1 - u));
	elseif (u <= 1.5e+15)
		tmp = -v / t1;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(t1 * N[(v / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / u), $MachinePrecision]}, If[LessEqual[u, -3.2e-53], t$95$1, If[LessEqual[u, 4.6e-88], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 3e-9], N[(t1 * N[(N[(v / u), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.5e+15], N[((-v) / t1), $MachinePrecision], t$95$1]]]]]

Derivation

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

Alternative 3: 79.4% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_1 := \frac{t1 \cdot \frac{v}{t1 - u}}{u}\\ \mathbf{if}\;u \leq -6.5 \cdot 10^{-51}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;u \leq 4.6 \cdot 10^{-88}:\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{elif}\;u \leq 5 \cdot 10^{-9}:\\ \;\;\;\;\frac{t1}{\left(t1 - u\right) \cdot \frac{t1 + u}{v}}\\ \mathbf{elif}\;u \leq 1.8 \cdot 10^{+15}:\\ \;\;\;\;\frac{-v}{t1}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (let* ((t_1 (/ (* t1 (/ v (- t1 u))) u)))
   (if (<= u -6.5e-51)
     t_1
     (if (<= u 4.6e-88)
       (/ v (- (* u -2.0) t1))
       (if (<= u 5e-9)
         (/ t1 (* (- t1 u) (/ (+ t1 u) v)))
         (if (<= u 1.8e+15) (/ (- v) t1) t_1))))))

C

double code(double u, double v, double t1) {
	double t_1 = (t1 * (v / (t1 - u))) / u;
	double tmp;
	if (u <= -6.5e-51) {
		tmp = t_1;
	} else if (u <= 4.6e-88) {
		tmp = v / ((u * -2.0) - t1);
	} else if (u <= 5e-9) {
		tmp = t1 / ((t1 - u) * ((t1 + u) / v));
	} else if (u <= 1.8e+15) {
		tmp = -v / t1;
	} else {
		tmp = t_1;
	}
	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 = (t1 * (v / (t1 - u))) / u
    if (u <= (-6.5d-51)) then
        tmp = t_1
    else if (u <= 4.6d-88) then
        tmp = v / ((u * (-2.0d0)) - t1)
    else if (u <= 5d-9) then
        tmp = t1 / ((t1 - u) * ((t1 + u) / v))
    else if (u <= 1.8d+15) then
        tmp = -v / t1
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double t_1 = (t1 * (v / (t1 - u))) / u;
	double tmp;
	if (u <= -6.5e-51) {
		tmp = t_1;
	} else if (u <= 4.6e-88) {
		tmp = v / ((u * -2.0) - t1);
	} else if (u <= 5e-9) {
		tmp = t1 / ((t1 - u) * ((t1 + u) / v));
	} else if (u <= 1.8e+15) {
		tmp = -v / t1;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	t_1 = (t1 * (v / (t1 - u))) / u
	tmp = 0
	if u <= -6.5e-51:
		tmp = t_1
	elif u <= 4.6e-88:
		tmp = v / ((u * -2.0) - t1)
	elif u <= 5e-9:
		tmp = t1 / ((t1 - u) * ((t1 + u) / v))
	elif u <= 1.8e+15:
		tmp = -v / t1
	else:
		tmp = t_1
	return tmp

Julia

function code(u, v, t1)
	t_1 = Float64(Float64(t1 * Float64(v / Float64(t1 - u))) / u)
	tmp = 0.0
	if (u <= -6.5e-51)
		tmp = t_1;
	elseif (u <= 4.6e-88)
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	elseif (u <= 5e-9)
		tmp = Float64(t1 / Float64(Float64(t1 - u) * Float64(Float64(t1 + u) / v)));
	elseif (u <= 1.8e+15)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	t_1 = (t1 * (v / (t1 - u))) / u;
	tmp = 0.0;
	if (u <= -6.5e-51)
		tmp = t_1;
	elseif (u <= 4.6e-88)
		tmp = v / ((u * -2.0) - t1);
	elseif (u <= 5e-9)
		tmp = t1 / ((t1 - u) * ((t1 + u) / v));
	elseif (u <= 1.8e+15)
		tmp = -v / t1;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(t1 * N[(v / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / u), $MachinePrecision]}, If[LessEqual[u, -6.5e-51], t$95$1, If[LessEqual[u, 4.6e-88], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 5e-9], N[(t1 / N[(N[(t1 - u), $MachinePrecision] * N[(N[(t1 + u), $MachinePrecision] / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.8e+15], N[((-v) / t1), $MachinePrecision], t$95$1]]]]]

Derivation

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

Alternative 4: 79.9% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -2.8e-36) (not (<= t1 5.6e-49)))
   (/ v (- (* u -2.0) t1))
   (* (/ v u) (/ (- t1) u))))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -2.8e-36) || !(t1 <= 5.6e-49)) {
		tmp = v / ((u * -2.0) - 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 ((t1 <= (-2.8d-36)) .or. (.not. (t1 <= 5.6d-49))) then
        tmp = v / ((u * (-2.0d0)) - 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 ((t1 <= -2.8e-36) || !(t1 <= 5.6e-49)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (v / u) * (-t1 / u);
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 5: 79.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;t1 \leq -3.2 \cdot 10^{-38} \lor \neg \left(t1 \leq 1.75 \cdot 10^{-48}\right):\\ \;\;\;\;\frac{v}{u \cdot -2 - t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{t1 \cdot \frac{-v}{u}}{u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= t1 -3.2e-38) (not (<= t1 1.75e-48)))
   (/ v (- (* u -2.0) t1))
   (/ (* t1 (/ (- v) u)) u)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -3.2e-38) || !(t1 <= 1.75e-48)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (t1 * (-v / u)) / u;
	}
	return tmp;
}

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    real(8) :: tmp
    if ((t1 <= (-3.2d-38)) .or. (.not. (t1 <= 1.75d-48))) then
        tmp = v / ((u * (-2.0d0)) - t1)
    else
        tmp = (t1 * (-v / u)) / u
    end if
    code = tmp
end function

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if ((t1 <= -3.2e-38) || !(t1 <= 1.75e-48)) {
		tmp = v / ((u * -2.0) - t1);
	} else {
		tmp = (t1 * (-v / u)) / u;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (t1 <= -3.2e-38) or not (t1 <= 1.75e-48):
		tmp = v / ((u * -2.0) - t1)
	else:
		tmp = (t1 * (-v / u)) / u
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((t1 <= -3.2e-38) || !(t1 <= 1.75e-48))
		tmp = Float64(v / Float64(Float64(u * -2.0) - t1));
	else
		tmp = Float64(Float64(t1 * Float64(Float64(-v) / u)) / u);
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if ((t1 <= -3.2e-38) || ~((t1 <= 1.75e-48)))
		tmp = v / ((u * -2.0) - t1);
	else
		tmp = (t1 * (-v / u)) / u;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[t1, -3.2e-38], N[Not[LessEqual[t1, 1.75e-48]], $MachinePrecision]], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(N[(t1 * N[((-v) / u), $MachinePrecision]), $MachinePrecision] / u), $MachinePrecision]]

Derivation

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

Alternative 6: 59.6% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -1e+159) (not (<= u 4.6e+82)))
   (* v (/ t1 (* t1 u)))
   (/ (- v) t1)))

C

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

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -1e+159) or not (u <= 4.6e+82):
		tmp = v * (t1 / (t1 * u))
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -1e+159) || !(u <= 4.6e+82))
		tmp = Float64(v * Float64(t1 / 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 <= -1e+159) || ~((u <= 4.6e+82)))
		tmp = v * (t1 / (t1 * u));
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -1e+159], N[Not[LessEqual[u, 4.6e+82]], $MachinePrecision]], N[(v * N[(t1 / N[(t1 * u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 7: 58.1% accurate, 1.3× speedup

Math

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

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -6.5e+158) (not (<= u 1.35e+83)))
   (* (/ v u) -0.5)
   (/ (- v) t1)))

C

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

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -6.5e+158) or not (u <= 1.35e+83):
		tmp = (v / u) * -0.5
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -6.5e+158) || !(u <= 1.35e+83))
		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 <= -6.5e+158) || ~((u <= 1.35e+83)))
		tmp = (v / u) * -0.5;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -6.5e+158], N[Not[LessEqual[u, 1.35e+83]], $MachinePrecision]], N[(N[(v / u), $MachinePrecision] * -0.5), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 8: 58.4% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -7 \cdot 10^{+158}:\\ \;\;\;\;\frac{v}{u} \cdot -0.5\\ \mathbf{elif}\;u \leq 2.45 \cdot 10^{+82}:\\ \;\;\;\;\frac{-v}{t1}\\ \mathbf{else}:\\ \;\;\;\;\frac{v}{t1 + u}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (<= u -7e+158)
   (* (/ v u) -0.5)
   (if (<= u 2.45e+82) (/ (- v) t1) (/ v (+ t1 u)))))

C

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

Java

public static double code(double u, double v, double t1) {
	double tmp;
	if (u <= -7e+158) {
		tmp = (v / u) * -0.5;
	} else if (u <= 2.45e+82) {
		tmp = -v / t1;
	} else {
		tmp = v / (t1 + u);
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if u <= -7e+158:
		tmp = (v / u) * -0.5
	elif u <= 2.45e+82:
		tmp = -v / t1
	else:
		tmp = v / (t1 + u)
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if (u <= -7e+158)
		tmp = Float64(Float64(v / u) * -0.5);
	elseif (u <= 2.45e+82)
		tmp = Float64(Float64(-v) / t1);
	else
		tmp = Float64(v / Float64(t1 + u));
	end
	return tmp
end

MATLAB

function tmp_2 = code(u, v, t1)
	tmp = 0.0;
	if (u <= -7e+158)
		tmp = (v / u) * -0.5;
	elseif (u <= 2.45e+82)
		tmp = -v / t1;
	else
		tmp = v / (t1 + u);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 9: 58.1% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -7.5 \cdot 10^{+158} \lor \neg \left(u \leq 1.9 \cdot 10^{+83}\right):\\ \;\;\;\;\frac{v}{u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -7.5e+158) (not (<= u 1.9e+83))) (/ v u) (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -7.5e+158) || !(u <= 1.9e+83)) {
		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.5d+158)) .or. (.not. (u <= 1.9d+83))) 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.5e+158) || !(u <= 1.9e+83)) {
		tmp = v / u;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -7.5e+158) or not (u <= 1.9e+83):
		tmp = v / u
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -7.5e+158) || !(u <= 1.9e+83))
		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 <= -7.5e+158) || ~((u <= 1.9e+83)))
		tmp = v / u;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -7.5e+158], N[Not[LessEqual[u, 1.9e+83]], $MachinePrecision]], N[(v / u), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 10: 58.1% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;u \leq -7.5 \cdot 10^{+158} \lor \neg \left(u \leq 1.9 \cdot 10^{+83}\right):\\ \;\;\;\;\frac{-v}{u}\\ \mathbf{else}:\\ \;\;\;\;\frac{-v}{t1}\\ \end{array} \end{array} \]

FPCore

(FPCore (u v t1)
 :precision binary64
 (if (or (<= u -7.5e+158) (not (<= u 1.9e+83))) (/ (- v) u) (/ (- v) t1)))

C

double code(double u, double v, double t1) {
	double tmp;
	if ((u <= -7.5e+158) || !(u <= 1.9e+83)) {
		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.5d+158)) .or. (.not. (u <= 1.9d+83))) 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.5e+158) || !(u <= 1.9e+83)) {
		tmp = -v / u;
	} else {
		tmp = -v / t1;
	}
	return tmp;
}

Python

def code(u, v, t1):
	tmp = 0
	if (u <= -7.5e+158) or not (u <= 1.9e+83):
		tmp = -v / u
	else:
		tmp = -v / t1
	return tmp

Julia

function code(u, v, t1)
	tmp = 0.0
	if ((u <= -7.5e+158) || !(u <= 1.9e+83))
		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.5e+158) || ~((u <= 1.9e+83)))
		tmp = -v / u;
	else
		tmp = -v / t1;
	end
	tmp_2 = tmp;
end

Wolfram

code[u_, v_, t1_] := If[Or[LessEqual[u, -7.5e+158], N[Not[LessEqual[u, 1.9e+83]], $MachinePrecision]], N[((-v) / u), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]

Derivation

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

Alternative 11: 62.1% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 12: 16.9% accurate, 4.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(u, v, t1)
    real(8), intent (in) :: u
    real(8), intent (in) :: v
    real(8), intent (in) :: t1
    code = v / u
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Reproduce

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