
(FPCore (u v t1) :precision binary64 (/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))
double code(double u, double v, double t1) {
return (-t1 * v) / ((t1 + u) * (t1 + u));
}
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
public static double code(double u, double v, double t1) {
return (-t1 * v) / ((t1 + u) * (t1 + u));
}
def code(u, v, t1): return (-t1 * v) / ((t1 + u) * (t1 + u))
function code(u, v, t1) return Float64(Float64(Float64(-t1) * v) / Float64(Float64(t1 + u) * Float64(t1 + u))) end
function tmp = code(u, v, t1) tmp = (-t1 * v) / ((t1 + u) * (t1 + u)); end
code[u_, v_, t1_] := N[(N[((-t1) * v), $MachinePrecision] / N[(N[(t1 + u), $MachinePrecision] * N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (u v t1) :precision binary64 (/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))
double code(double u, double v, double t1) {
return (-t1 * v) / ((t1 + u) * (t1 + u));
}
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
public static double code(double u, double v, double t1) {
return (-t1 * v) / ((t1 + u) * (t1 + u));
}
def code(u, v, t1): return (-t1 * v) / ((t1 + u) * (t1 + u))
function code(u, v, t1) return Float64(Float64(Float64(-t1) * v) / Float64(Float64(t1 + u) * Float64(t1 + u))) end
function tmp = code(u, v, t1) tmp = (-t1 * v) / ((t1 + u) * (t1 + u)); end
code[u_, v_, t1_] := N[(N[((-t1) * v), $MachinePrecision] / N[(N[(t1 + u), $MachinePrecision] * N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-t1\right) \cdot v}{\left(t1 + u\right) \cdot \left(t1 + u\right)}
\end{array}
(FPCore (u v t1) :precision binary64 (/ (/ v (+ t1 u)) (fma -1.0 (/ u t1) -1.0)))
double code(double u, double v, double t1) {
return (v / (t1 + u)) / fma(-1.0, (u / t1), -1.0);
}
function code(u, v, t1) return Float64(Float64(v / Float64(t1 + u)) / fma(-1.0, Float64(u / t1), -1.0)) end
code[u_, v_, t1_] := N[(N[(v / N[(t1 + u), $MachinePrecision]), $MachinePrecision] / N[(-1.0 * N[(u / t1), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{v}{t1 + u}}{\mathsf{fma}\left(-1, \frac{u}{t1}, -1\right)}
\end{array}
Initial program 77.7%
associate-/r*87.6%
*-commutative87.6%
associate-/l*98.6%
associate-/l/95.4%
+-commutative95.4%
remove-double-neg95.4%
unsub-neg95.4%
div-sub95.4%
sub-neg95.4%
*-inverses95.4%
metadata-eval95.4%
Simplified95.4%
Taylor expanded in v around 0 95.4%
associate-/r*97.7%
fma-neg97.7%
metadata-eval97.7%
Simplified97.7%
Final simplification97.7%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (* (/ v u) (/ t1 (- t1 u)))))
(if (<= u -1.05e+69)
t_1
(if (<= u -8.5e-33)
(/ (- v) (+ t1 (* u -2.0)))
(if (<= u -1.66e-56)
t_1
(if (<= u 7.6e-88)
(/ (- v) t1)
(if (<= u 2.5e-31)
(* v (/ (/ t1 u) (- t1 u)))
(if (<= u 8.5e+58) (/ v (- (* u -2.0) t1)) t_1))))))))
double code(double u, double v, double t1) {
double t_1 = (v / u) * (t1 / (t1 - u));
double tmp;
if (u <= -1.05e+69) {
tmp = t_1;
} else if (u <= -8.5e-33) {
tmp = -v / (t1 + (u * -2.0));
} else if (u <= -1.66e-56) {
tmp = t_1;
} else if (u <= 7.6e-88) {
tmp = -v / t1;
} else if (u <= 2.5e-31) {
tmp = v * ((t1 / u) / (t1 - u));
} else if (u <= 8.5e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = t_1;
}
return tmp;
}
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 / u) * (t1 / (t1 - u))
if (u <= (-1.05d+69)) then
tmp = t_1
else if (u <= (-8.5d-33)) then
tmp = -v / (t1 + (u * (-2.0d0)))
else if (u <= (-1.66d-56)) then
tmp = t_1
else if (u <= 7.6d-88) then
tmp = -v / t1
else if (u <= 2.5d-31) then
tmp = v * ((t1 / u) / (t1 - u))
else if (u <= 8.5d+58) then
tmp = v / ((u * (-2.0d0)) - t1)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = (v / u) * (t1 / (t1 - u));
double tmp;
if (u <= -1.05e+69) {
tmp = t_1;
} else if (u <= -8.5e-33) {
tmp = -v / (t1 + (u * -2.0));
} else if (u <= -1.66e-56) {
tmp = t_1;
} else if (u <= 7.6e-88) {
tmp = -v / t1;
} else if (u <= 2.5e-31) {
tmp = v * ((t1 / u) / (t1 - u));
} else if (u <= 8.5e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = t_1;
}
return tmp;
}
def code(u, v, t1): t_1 = (v / u) * (t1 / (t1 - u)) tmp = 0 if u <= -1.05e+69: tmp = t_1 elif u <= -8.5e-33: tmp = -v / (t1 + (u * -2.0)) elif u <= -1.66e-56: tmp = t_1 elif u <= 7.6e-88: tmp = -v / t1 elif u <= 2.5e-31: tmp = v * ((t1 / u) / (t1 - u)) elif u <= 8.5e+58: tmp = v / ((u * -2.0) - t1) else: tmp = t_1 return tmp
function code(u, v, t1) t_1 = Float64(Float64(v / u) * Float64(t1 / Float64(t1 - u))) tmp = 0.0 if (u <= -1.05e+69) tmp = t_1; elseif (u <= -8.5e-33) tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * -2.0))); elseif (u <= -1.66e-56) tmp = t_1; elseif (u <= 7.6e-88) tmp = Float64(Float64(-v) / t1); elseif (u <= 2.5e-31) tmp = Float64(v * Float64(Float64(t1 / u) / Float64(t1 - u))); elseif (u <= 8.5e+58) tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); else tmp = t_1; end return tmp end
function tmp_2 = code(u, v, t1) t_1 = (v / u) * (t1 / (t1 - u)); tmp = 0.0; if (u <= -1.05e+69) tmp = t_1; elseif (u <= -8.5e-33) tmp = -v / (t1 + (u * -2.0)); elseif (u <= -1.66e-56) tmp = t_1; elseif (u <= 7.6e-88) tmp = -v / t1; elseif (u <= 2.5e-31) tmp = v * ((t1 / u) / (t1 - u)); elseif (u <= 8.5e+58) tmp = v / ((u * -2.0) - t1); else tmp = t_1; end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(v / u), $MachinePrecision] * N[(t1 / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -1.05e+69], t$95$1, If[LessEqual[u, -8.5e-33], N[((-v) / N[(t1 + N[(u * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, -1.66e-56], t$95$1, If[LessEqual[u, 7.6e-88], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 2.5e-31], N[(v * N[(N[(t1 / u), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 8.5e+58], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{v}{u} \cdot \frac{t1}{t1 - u}\\
\mathbf{if}\;u \leq -1.05 \cdot 10^{+69}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq -8.5 \cdot 10^{-33}:\\
\;\;\;\;\frac{-v}{t1 + u \cdot -2}\\
\mathbf{elif}\;u \leq -1.66 \cdot 10^{-56}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 7.6 \cdot 10^{-88}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 2.5 \cdot 10^{-31}:\\
\;\;\;\;v \cdot \frac{\frac{t1}{u}}{t1 - u}\\
\mathbf{elif}\;u \leq 8.5 \cdot 10^{+58}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if u < -1.05000000000000008e69 or -8.49999999999999945e-33 < u < -1.66000000000000001e-56 or 8.50000000000000015e58 < u Initial program 83.2%
times-frac98.9%
Simplified98.9%
*-commutative98.9%
clear-num98.8%
frac-2neg98.8%
frac-times91.1%
*-un-lft-identity91.1%
remove-double-neg91.1%
distribute-neg-in91.1%
add-sqr-sqrt50.1%
sqrt-unprod86.5%
sqr-neg86.5%
sqrt-unprod38.1%
add-sqr-sqrt86.5%
sub-neg86.5%
Applied egg-rr86.5%
Taylor expanded in t1 around 0 86.5%
*-un-lft-identity86.5%
times-frac89.9%
clear-num89.9%
Applied egg-rr89.9%
if -1.05000000000000008e69 < u < -8.49999999999999945e-33Initial program 69.5%
times-frac94.9%
Simplified94.9%
clear-num94.7%
frac-2neg94.7%
frac-times94.5%
*-un-lft-identity94.5%
frac-2neg94.5%
distribute-neg-in94.5%
add-sqr-sqrt36.9%
sqrt-unprod64.5%
sqr-neg64.5%
sqrt-unprod37.2%
add-sqr-sqrt53.7%
sub-neg53.7%
remove-double-neg53.7%
distribute-neg-in53.7%
add-sqr-sqrt16.5%
sqrt-unprod59.3%
sqr-neg59.3%
sqrt-unprod57.4%
add-sqr-sqrt94.5%
sub-neg94.5%
Applied egg-rr94.5%
associate-*l/69.9%
Simplified69.9%
Taylor expanded in t1 around inf 64.8%
*-commutative64.8%
Simplified64.8%
if -1.66000000000000001e-56 < u < 7.60000000000000022e-88Initial program 67.8%
times-frac97.9%
Simplified97.9%
Taylor expanded in t1 around inf 86.5%
associate-*r/86.5%
neg-mul-186.5%
Simplified86.5%
if 7.60000000000000022e-88 < u < 2.5e-31Initial program 89.4%
times-frac89.2%
Simplified89.2%
*-commutative89.2%
clear-num89.0%
frac-2neg89.0%
frac-times78.3%
*-un-lft-identity78.3%
remove-double-neg78.3%
distribute-neg-in78.3%
add-sqr-sqrt66.8%
sqrt-unprod67.6%
sqr-neg67.6%
sqrt-unprod0.9%
add-sqr-sqrt67.6%
sub-neg67.6%
Applied egg-rr67.6%
Taylor expanded in t1 around 0 67.6%
Taylor expanded in v around 0 68.3%
associate-*l/78.6%
*-commutative78.6%
associate-/r*78.6%
Simplified78.6%
if 2.5e-31 < u < 8.50000000000000015e58Initial program 95.0%
associate-/r*99.8%
*-commutative99.8%
associate-/l*96.5%
associate-/l/96.5%
+-commutative96.5%
remove-double-neg96.5%
unsub-neg96.5%
div-sub96.5%
sub-neg96.5%
*-inverses96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in t1 around inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
Final simplification84.6%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (/ (- v) t1)) (t_2 (* (/ v u) (/ t1 (- t1 u)))))
(if (<= u -4.2e+68)
t_2
(if (<= u -6.9e+59)
t_1
(if (<= u -9.7e-57)
(/ t1 (* (- t1 u) (/ u v)))
(if (<= u 7.6e-92)
t_1
(if (<= u 7.5e-32)
(* v (/ (/ t1 u) (- t1 u)))
(if (<= u 1.55e+60) (/ v (- (* u -2.0) t1)) t_2))))))))
double code(double u, double v, double t1) {
double t_1 = -v / t1;
double t_2 = (v / u) * (t1 / (t1 - u));
double tmp;
if (u <= -4.2e+68) {
tmp = t_2;
} else if (u <= -6.9e+59) {
tmp = t_1;
} else if (u <= -9.7e-57) {
tmp = t1 / ((t1 - u) * (u / v));
} else if (u <= 7.6e-92) {
tmp = t_1;
} else if (u <= 7.5e-32) {
tmp = v * ((t1 / u) / (t1 - u));
} else if (u <= 1.55e+60) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = t_2;
}
return tmp;
}
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) :: t_2
real(8) :: tmp
t_1 = -v / t1
t_2 = (v / u) * (t1 / (t1 - u))
if (u <= (-4.2d+68)) then
tmp = t_2
else if (u <= (-6.9d+59)) then
tmp = t_1
else if (u <= (-9.7d-57)) then
tmp = t1 / ((t1 - u) * (u / v))
else if (u <= 7.6d-92) then
tmp = t_1
else if (u <= 7.5d-32) then
tmp = v * ((t1 / u) / (t1 - u))
else if (u <= 1.55d+60) then
tmp = v / ((u * (-2.0d0)) - t1)
else
tmp = t_2
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = -v / t1;
double t_2 = (v / u) * (t1 / (t1 - u));
double tmp;
if (u <= -4.2e+68) {
tmp = t_2;
} else if (u <= -6.9e+59) {
tmp = t_1;
} else if (u <= -9.7e-57) {
tmp = t1 / ((t1 - u) * (u / v));
} else if (u <= 7.6e-92) {
tmp = t_1;
} else if (u <= 7.5e-32) {
tmp = v * ((t1 / u) / (t1 - u));
} else if (u <= 1.55e+60) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = t_2;
}
return tmp;
}
def code(u, v, t1): t_1 = -v / t1 t_2 = (v / u) * (t1 / (t1 - u)) tmp = 0 if u <= -4.2e+68: tmp = t_2 elif u <= -6.9e+59: tmp = t_1 elif u <= -9.7e-57: tmp = t1 / ((t1 - u) * (u / v)) elif u <= 7.6e-92: tmp = t_1 elif u <= 7.5e-32: tmp = v * ((t1 / u) / (t1 - u)) elif u <= 1.55e+60: tmp = v / ((u * -2.0) - t1) else: tmp = t_2 return tmp
function code(u, v, t1) t_1 = Float64(Float64(-v) / t1) t_2 = Float64(Float64(v / u) * Float64(t1 / Float64(t1 - u))) tmp = 0.0 if (u <= -4.2e+68) tmp = t_2; elseif (u <= -6.9e+59) tmp = t_1; elseif (u <= -9.7e-57) tmp = Float64(t1 / Float64(Float64(t1 - u) * Float64(u / v))); elseif (u <= 7.6e-92) tmp = t_1; elseif (u <= 7.5e-32) tmp = Float64(v * Float64(Float64(t1 / u) / Float64(t1 - u))); elseif (u <= 1.55e+60) tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); else tmp = t_2; end return tmp end
function tmp_2 = code(u, v, t1) t_1 = -v / t1; t_2 = (v / u) * (t1 / (t1 - u)); tmp = 0.0; if (u <= -4.2e+68) tmp = t_2; elseif (u <= -6.9e+59) tmp = t_1; elseif (u <= -9.7e-57) tmp = t1 / ((t1 - u) * (u / v)); elseif (u <= 7.6e-92) tmp = t_1; elseif (u <= 7.5e-32) tmp = v * ((t1 / u) / (t1 - u)); elseif (u <= 1.55e+60) tmp = v / ((u * -2.0) - t1); else tmp = t_2; end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[((-v) / t1), $MachinePrecision]}, Block[{t$95$2 = N[(N[(v / u), $MachinePrecision] * N[(t1 / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -4.2e+68], t$95$2, If[LessEqual[u, -6.9e+59], t$95$1, If[LessEqual[u, -9.7e-57], N[(t1 / N[(N[(t1 - u), $MachinePrecision] * N[(u / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 7.6e-92], t$95$1, If[LessEqual[u, 7.5e-32], N[(v * N[(N[(t1 / u), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.55e+60], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{-v}{t1}\\
t_2 := \frac{v}{u} \cdot \frac{t1}{t1 - u}\\
\mathbf{if}\;u \leq -4.2 \cdot 10^{+68}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;u \leq -6.9 \cdot 10^{+59}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq -9.7 \cdot 10^{-57}:\\
\;\;\;\;\frac{t1}{\left(t1 - u\right) \cdot \frac{u}{v}}\\
\mathbf{elif}\;u \leq 7.6 \cdot 10^{-92}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 7.5 \cdot 10^{-32}:\\
\;\;\;\;v \cdot \frac{\frac{t1}{u}}{t1 - u}\\
\mathbf{elif}\;u \leq 1.55 \cdot 10^{+60}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if u < -4.20000000000000002e68 or 1.55e60 < u Initial program 83.7%
times-frac98.8%
Simplified98.8%
*-commutative98.8%
clear-num98.8%
frac-2neg98.8%
frac-times91.7%
*-un-lft-identity91.7%
remove-double-neg91.7%
distribute-neg-in91.7%
add-sqr-sqrt50.1%
sqrt-unprod86.7%
sqr-neg86.7%
sqrt-unprod38.4%
add-sqr-sqrt87.6%
sub-neg87.6%
Applied egg-rr87.6%
Taylor expanded in t1 around 0 87.6%
*-un-lft-identity87.6%
times-frac90.9%
clear-num90.9%
Applied egg-rr90.9%
if -4.20000000000000002e68 < u < -6.8999999999999998e59 or -9.7e-57 < u < 7.6000000000000001e-92Initial program 65.6%
times-frac98.0%
Simplified98.0%
Taylor expanded in t1 around inf 87.2%
associate-*r/87.2%
neg-mul-187.2%
Simplified87.2%
if -6.8999999999999998e59 < u < -9.7e-57Initial program 82.9%
times-frac95.9%
Simplified95.9%
*-commutative95.9%
clear-num95.7%
frac-2neg95.7%
frac-times81.8%
*-un-lft-identity81.8%
remove-double-neg81.8%
distribute-neg-in81.8%
add-sqr-sqrt37.8%
sqrt-unprod77.7%
sqr-neg77.7%
sqrt-unprod39.9%
add-sqr-sqrt69.4%
sub-neg69.4%
Applied egg-rr69.4%
Taylor expanded in t1 around 0 69.4%
if 7.6000000000000001e-92 < u < 7.49999999999999953e-32Initial program 89.4%
times-frac89.2%
Simplified89.2%
*-commutative89.2%
clear-num89.0%
frac-2neg89.0%
frac-times78.3%
*-un-lft-identity78.3%
remove-double-neg78.3%
distribute-neg-in78.3%
add-sqr-sqrt66.8%
sqrt-unprod67.6%
sqr-neg67.6%
sqrt-unprod0.9%
add-sqr-sqrt67.6%
sub-neg67.6%
Applied egg-rr67.6%
Taylor expanded in t1 around 0 67.6%
Taylor expanded in v around 0 68.3%
associate-*l/78.6%
*-commutative78.6%
associate-/r*78.6%
Simplified78.6%
if 7.49999999999999953e-32 < u < 1.55e60Initial program 95.0%
associate-/r*99.8%
*-commutative99.8%
associate-/l*96.5%
associate-/l/96.5%
+-commutative96.5%
remove-double-neg96.5%
unsub-neg96.5%
div-sub96.5%
sub-neg96.5%
*-inverses96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in t1 around inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
Final simplification85.1%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (/ (- v) t1)) (t_2 (* (/ v u) (/ t1 (- t1 u)))))
(if (<= u -4.2e+68)
t_2
(if (<= u -6.9e+59)
t_1
(if (<= u -6.1e-56)
(/ t1 (/ (* u (- t1 u)) v))
(if (<= u 7.6e-88)
t_1
(if (<= u 2.1e-32)
(* v (/ (/ t1 u) (- t1 u)))
(if (<= u 7e+59) (/ v (- (* u -2.0) t1)) t_2))))))))
double code(double u, double v, double t1) {
double t_1 = -v / t1;
double t_2 = (v / u) * (t1 / (t1 - u));
double tmp;
if (u <= -4.2e+68) {
tmp = t_2;
} else if (u <= -6.9e+59) {
tmp = t_1;
} else if (u <= -6.1e-56) {
tmp = t1 / ((u * (t1 - u)) / v);
} else if (u <= 7.6e-88) {
tmp = t_1;
} else if (u <= 2.1e-32) {
tmp = v * ((t1 / u) / (t1 - u));
} else if (u <= 7e+59) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = t_2;
}
return tmp;
}
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) :: t_2
real(8) :: tmp
t_1 = -v / t1
t_2 = (v / u) * (t1 / (t1 - u))
if (u <= (-4.2d+68)) then
tmp = t_2
else if (u <= (-6.9d+59)) then
tmp = t_1
else if (u <= (-6.1d-56)) then
tmp = t1 / ((u * (t1 - u)) / v)
else if (u <= 7.6d-88) then
tmp = t_1
else if (u <= 2.1d-32) then
tmp = v * ((t1 / u) / (t1 - u))
else if (u <= 7d+59) then
tmp = v / ((u * (-2.0d0)) - t1)
else
tmp = t_2
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = -v / t1;
double t_2 = (v / u) * (t1 / (t1 - u));
double tmp;
if (u <= -4.2e+68) {
tmp = t_2;
} else if (u <= -6.9e+59) {
tmp = t_1;
} else if (u <= -6.1e-56) {
tmp = t1 / ((u * (t1 - u)) / v);
} else if (u <= 7.6e-88) {
tmp = t_1;
} else if (u <= 2.1e-32) {
tmp = v * ((t1 / u) / (t1 - u));
} else if (u <= 7e+59) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = t_2;
}
return tmp;
}
def code(u, v, t1): t_1 = -v / t1 t_2 = (v / u) * (t1 / (t1 - u)) tmp = 0 if u <= -4.2e+68: tmp = t_2 elif u <= -6.9e+59: tmp = t_1 elif u <= -6.1e-56: tmp = t1 / ((u * (t1 - u)) / v) elif u <= 7.6e-88: tmp = t_1 elif u <= 2.1e-32: tmp = v * ((t1 / u) / (t1 - u)) elif u <= 7e+59: tmp = v / ((u * -2.0) - t1) else: tmp = t_2 return tmp
function code(u, v, t1) t_1 = Float64(Float64(-v) / t1) t_2 = Float64(Float64(v / u) * Float64(t1 / Float64(t1 - u))) tmp = 0.0 if (u <= -4.2e+68) tmp = t_2; elseif (u <= -6.9e+59) tmp = t_1; elseif (u <= -6.1e-56) tmp = Float64(t1 / Float64(Float64(u * Float64(t1 - u)) / v)); elseif (u <= 7.6e-88) tmp = t_1; elseif (u <= 2.1e-32) tmp = Float64(v * Float64(Float64(t1 / u) / Float64(t1 - u))); elseif (u <= 7e+59) tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); else tmp = t_2; end return tmp end
function tmp_2 = code(u, v, t1) t_1 = -v / t1; t_2 = (v / u) * (t1 / (t1 - u)); tmp = 0.0; if (u <= -4.2e+68) tmp = t_2; elseif (u <= -6.9e+59) tmp = t_1; elseif (u <= -6.1e-56) tmp = t1 / ((u * (t1 - u)) / v); elseif (u <= 7.6e-88) tmp = t_1; elseif (u <= 2.1e-32) tmp = v * ((t1 / u) / (t1 - u)); elseif (u <= 7e+59) tmp = v / ((u * -2.0) - t1); else tmp = t_2; end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[((-v) / t1), $MachinePrecision]}, Block[{t$95$2 = N[(N[(v / u), $MachinePrecision] * N[(t1 / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -4.2e+68], t$95$2, If[LessEqual[u, -6.9e+59], t$95$1, If[LessEqual[u, -6.1e-56], N[(t1 / N[(N[(u * N[(t1 - u), $MachinePrecision]), $MachinePrecision] / v), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 7.6e-88], t$95$1, If[LessEqual[u, 2.1e-32], N[(v * N[(N[(t1 / u), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 7e+59], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{-v}{t1}\\
t_2 := \frac{v}{u} \cdot \frac{t1}{t1 - u}\\
\mathbf{if}\;u \leq -4.2 \cdot 10^{+68}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;u \leq -6.9 \cdot 10^{+59}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq -6.1 \cdot 10^{-56}:\\
\;\;\;\;\frac{t1}{\frac{u \cdot \left(t1 - u\right)}{v}}\\
\mathbf{elif}\;u \leq 7.6 \cdot 10^{-88}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 2.1 \cdot 10^{-32}:\\
\;\;\;\;v \cdot \frac{\frac{t1}{u}}{t1 - u}\\
\mathbf{elif}\;u \leq 7 \cdot 10^{+59}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if u < -4.20000000000000002e68 or 7e59 < u Initial program 83.7%
times-frac98.8%
Simplified98.8%
*-commutative98.8%
clear-num98.8%
frac-2neg98.8%
frac-times91.7%
*-un-lft-identity91.7%
remove-double-neg91.7%
distribute-neg-in91.7%
add-sqr-sqrt50.1%
sqrt-unprod86.7%
sqr-neg86.7%
sqrt-unprod38.4%
add-sqr-sqrt87.6%
sub-neg87.6%
Applied egg-rr87.6%
Taylor expanded in t1 around 0 87.6%
*-un-lft-identity87.6%
times-frac90.9%
clear-num90.9%
Applied egg-rr90.9%
if -4.20000000000000002e68 < u < -6.8999999999999998e59 or -6.0999999999999998e-56 < u < 7.60000000000000022e-88Initial program 65.6%
times-frac98.0%
Simplified98.0%
Taylor expanded in t1 around inf 87.2%
associate-*r/87.2%
neg-mul-187.2%
Simplified87.2%
if -6.8999999999999998e59 < u < -6.0999999999999998e-56Initial program 82.9%
times-frac95.9%
Simplified95.9%
*-commutative95.9%
clear-num95.7%
frac-2neg95.7%
frac-times81.8%
*-un-lft-identity81.8%
remove-double-neg81.8%
distribute-neg-in81.8%
add-sqr-sqrt37.8%
sqrt-unprod77.7%
sqr-neg77.7%
sqrt-unprod39.9%
add-sqr-sqrt69.4%
sub-neg69.4%
Applied egg-rr69.4%
Taylor expanded in t1 around 0 69.4%
Taylor expanded in v around 0 69.4%
if 7.60000000000000022e-88 < u < 2.0999999999999999e-32Initial program 89.4%
times-frac89.2%
Simplified89.2%
*-commutative89.2%
clear-num89.0%
frac-2neg89.0%
frac-times78.3%
*-un-lft-identity78.3%
remove-double-neg78.3%
distribute-neg-in78.3%
add-sqr-sqrt66.8%
sqrt-unprod67.6%
sqr-neg67.6%
sqrt-unprod0.9%
add-sqr-sqrt67.6%
sub-neg67.6%
Applied egg-rr67.6%
Taylor expanded in t1 around 0 67.6%
Taylor expanded in v around 0 68.3%
associate-*l/78.6%
*-commutative78.6%
associate-/r*78.6%
Simplified78.6%
if 2.0999999999999999e-32 < u < 7e59Initial program 95.0%
associate-/r*99.8%
*-commutative99.8%
associate-/l*96.5%
associate-/l/96.5%
+-commutative96.5%
remove-double-neg96.5%
unsub-neg96.5%
div-sub96.5%
sub-neg96.5%
*-inverses96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in t1 around inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
Final simplification85.1%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (* v (/ (- t1) (* (+ t1 u) (+ t1 u))))))
(if (<= t1 -1.4e+154)
(/ v (- (* u -2.0) t1))
(if (<= t1 -2.2e-242)
t_1
(if (<= t1 7e-216)
(/ (/ (* v t1) (- t1 u)) u)
(if (<= t1 6.5e+136) t_1 (/ (- v) (+ t1 (* u -2.0)))))))))
double code(double u, double v, double t1) {
double t_1 = v * (-t1 / ((t1 + u) * (t1 + u)));
double tmp;
if (t1 <= -1.4e+154) {
tmp = v / ((u * -2.0) - t1);
} else if (t1 <= -2.2e-242) {
tmp = t_1;
} else if (t1 <= 7e-216) {
tmp = ((v * t1) / (t1 - u)) / u;
} else if (t1 <= 6.5e+136) {
tmp = t_1;
} else {
tmp = -v / (t1 + (u * -2.0));
}
return tmp;
}
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 (t1 <= (-1.4d+154)) then
tmp = v / ((u * (-2.0d0)) - t1)
else if (t1 <= (-2.2d-242)) then
tmp = t_1
else if (t1 <= 7d-216) then
tmp = ((v * t1) / (t1 - u)) / u
else if (t1 <= 6.5d+136) then
tmp = t_1
else
tmp = -v / (t1 + (u * (-2.0d0)))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = v * (-t1 / ((t1 + u) * (t1 + u)));
double tmp;
if (t1 <= -1.4e+154) {
tmp = v / ((u * -2.0) - t1);
} else if (t1 <= -2.2e-242) {
tmp = t_1;
} else if (t1 <= 7e-216) {
tmp = ((v * t1) / (t1 - u)) / u;
} else if (t1 <= 6.5e+136) {
tmp = t_1;
} else {
tmp = -v / (t1 + (u * -2.0));
}
return tmp;
}
def code(u, v, t1): t_1 = v * (-t1 / ((t1 + u) * (t1 + u))) tmp = 0 if t1 <= -1.4e+154: tmp = v / ((u * -2.0) - t1) elif t1 <= -2.2e-242: tmp = t_1 elif t1 <= 7e-216: tmp = ((v * t1) / (t1 - u)) / u elif t1 <= 6.5e+136: tmp = t_1 else: tmp = -v / (t1 + (u * -2.0)) return tmp
function code(u, v, t1) t_1 = Float64(v * Float64(Float64(-t1) / Float64(Float64(t1 + u) * Float64(t1 + u)))) tmp = 0.0 if (t1 <= -1.4e+154) tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); elseif (t1 <= -2.2e-242) tmp = t_1; elseif (t1 <= 7e-216) tmp = Float64(Float64(Float64(v * t1) / Float64(t1 - u)) / u); elseif (t1 <= 6.5e+136) tmp = t_1; else tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * -2.0))); end return tmp end
function tmp_2 = code(u, v, t1) t_1 = v * (-t1 / ((t1 + u) * (t1 + u))); tmp = 0.0; if (t1 <= -1.4e+154) tmp = v / ((u * -2.0) - t1); elseif (t1 <= -2.2e-242) tmp = t_1; elseif (t1 <= 7e-216) tmp = ((v * t1) / (t1 - u)) / u; elseif (t1 <= 6.5e+136) tmp = t_1; else tmp = -v / (t1 + (u * -2.0)); end tmp_2 = tmp; end
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[t1, -1.4e+154], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t1, -2.2e-242], t$95$1, If[LessEqual[t1, 7e-216], N[(N[(N[(v * t1), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision] / u), $MachinePrecision], If[LessEqual[t1, 6.5e+136], t$95$1, N[((-v) / N[(t1 + N[(u * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := v \cdot \frac{-t1}{\left(t1 + u\right) \cdot \left(t1 + u\right)}\\
\mathbf{if}\;t1 \leq -1.4 \cdot 10^{+154}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\mathbf{elif}\;t1 \leq -2.2 \cdot 10^{-242}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t1 \leq 7 \cdot 10^{-216}:\\
\;\;\;\;\frac{\frac{v \cdot t1}{t1 - u}}{u}\\
\mathbf{elif}\;t1 \leq 6.5 \cdot 10^{+136}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{t1 + u \cdot -2}\\
\end{array}
\end{array}
if t1 < -1.4e154Initial program 51.5%
associate-/r*73.5%
*-commutative73.5%
associate-/l*99.9%
associate-/l/99.9%
+-commutative99.9%
remove-double-neg99.9%
unsub-neg99.9%
div-sub99.9%
sub-neg99.9%
*-inverses99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in t1 around inf 92.2%
mul-1-neg92.2%
unsub-neg92.2%
*-commutative92.2%
Simplified92.2%
if -1.4e154 < t1 < -2.20000000000000002e-242 or 6.99999999999999965e-216 < t1 < 6.4999999999999998e136Initial program 87.4%
times-frac98.6%
Simplified98.6%
Taylor expanded in v around 0 87.4%
mul-1-neg87.4%
associate-*l/93.2%
*-commutative93.2%
distribute-rgt-neg-in93.2%
Simplified93.2%
unpow293.2%
Applied egg-rr93.2%
if -2.20000000000000002e-242 < t1 < 6.99999999999999965e-216Initial program 77.9%
times-frac90.5%
Simplified90.5%
*-commutative90.5%
clear-num90.4%
frac-2neg90.4%
frac-times82.0%
*-un-lft-identity82.0%
remove-double-neg82.0%
distribute-neg-in82.0%
add-sqr-sqrt38.3%
sqrt-unprod76.7%
sqr-neg76.7%
sqrt-unprod41.0%
add-sqr-sqrt76.5%
sub-neg76.5%
Applied egg-rr76.5%
Taylor expanded in t1 around 0 79.3%
associate-*l/76.7%
associate-/r/72.1%
Applied egg-rr72.1%
associate-*l/77.9%
*-commutative77.9%
associate-/r*88.3%
Applied egg-rr88.3%
if 6.4999999999999998e136 < t1 Initial program 45.7%
times-frac100.0%
Simplified100.0%
clear-num99.9%
frac-2neg99.9%
frac-times97.0%
*-un-lft-identity97.0%
frac-2neg97.0%
distribute-neg-in97.0%
add-sqr-sqrt0.0%
sqrt-unprod43.7%
sqr-neg43.7%
sqrt-unprod45.8%
add-sqr-sqrt45.8%
sub-neg45.8%
remove-double-neg45.8%
distribute-neg-in45.8%
add-sqr-sqrt0.0%
sqrt-unprod49.5%
sqr-neg49.5%
sqrt-unprod96.7%
add-sqr-sqrt97.0%
sub-neg97.0%
Applied egg-rr97.0%
associate-*l/49.5%
Simplified49.5%
Taylor expanded in t1 around inf 91.5%
*-commutative91.5%
Simplified91.5%
Final simplification92.2%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (* (/ v (+ t1 u)) (/ (- t1) u))))
(if (<= u -5.5e-58)
t_1
(if (<= u 7.6e-88)
(/ (- v) t1)
(if (<= u 4.7e-32)
t_1
(if (<= u 9.6e+58)
(/ v (- (* u -2.0) t1))
(/ 1.0 (/ (- t1 u) (* t1 (/ v u))))))))))
double code(double u, double v, double t1) {
double t_1 = (v / (t1 + u)) * (-t1 / u);
double tmp;
if (u <= -5.5e-58) {
tmp = t_1;
} else if (u <= 7.6e-88) {
tmp = -v / t1;
} else if (u <= 4.7e-32) {
tmp = t_1;
} else if (u <= 9.6e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = 1.0 / ((t1 - u) / (t1 * (v / u)));
}
return tmp;
}
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 + u)) * (-t1 / u)
if (u <= (-5.5d-58)) then
tmp = t_1
else if (u <= 7.6d-88) then
tmp = -v / t1
else if (u <= 4.7d-32) then
tmp = t_1
else if (u <= 9.6d+58) then
tmp = v / ((u * (-2.0d0)) - t1)
else
tmp = 1.0d0 / ((t1 - u) / (t1 * (v / u)))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = (v / (t1 + u)) * (-t1 / u);
double tmp;
if (u <= -5.5e-58) {
tmp = t_1;
} else if (u <= 7.6e-88) {
tmp = -v / t1;
} else if (u <= 4.7e-32) {
tmp = t_1;
} else if (u <= 9.6e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = 1.0 / ((t1 - u) / (t1 * (v / u)));
}
return tmp;
}
def code(u, v, t1): t_1 = (v / (t1 + u)) * (-t1 / u) tmp = 0 if u <= -5.5e-58: tmp = t_1 elif u <= 7.6e-88: tmp = -v / t1 elif u <= 4.7e-32: tmp = t_1 elif u <= 9.6e+58: tmp = v / ((u * -2.0) - t1) else: tmp = 1.0 / ((t1 - u) / (t1 * (v / u))) return tmp
function code(u, v, t1) t_1 = Float64(Float64(v / Float64(t1 + u)) * Float64(Float64(-t1) / u)) tmp = 0.0 if (u <= -5.5e-58) tmp = t_1; elseif (u <= 7.6e-88) tmp = Float64(Float64(-v) / t1); elseif (u <= 4.7e-32) tmp = t_1; elseif (u <= 9.6e+58) tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); else tmp = Float64(1.0 / Float64(Float64(t1 - u) / Float64(t1 * Float64(v / u)))); end return tmp end
function tmp_2 = code(u, v, t1) t_1 = (v / (t1 + u)) * (-t1 / u); tmp = 0.0; if (u <= -5.5e-58) tmp = t_1; elseif (u <= 7.6e-88) tmp = -v / t1; elseif (u <= 4.7e-32) tmp = t_1; elseif (u <= 9.6e+58) tmp = v / ((u * -2.0) - t1); else tmp = 1.0 / ((t1 - u) / (t1 * (v / u))); end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(v / N[(t1 + u), $MachinePrecision]), $MachinePrecision] * N[((-t1) / u), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -5.5e-58], t$95$1, If[LessEqual[u, 7.6e-88], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 4.7e-32], t$95$1, If[LessEqual[u, 9.6e+58], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(t1 - u), $MachinePrecision] / N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{v}{t1 + u} \cdot \frac{-t1}{u}\\
\mathbf{if}\;u \leq -5.5 \cdot 10^{-58}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 7.6 \cdot 10^{-88}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 4.7 \cdot 10^{-32}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 9.6 \cdot 10^{+58}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{t1 - u}{t1 \cdot \frac{v}{u}}}\\
\end{array}
\end{array}
if u < -5.49999999999999996e-58 or 7.60000000000000022e-88 < u < 4.70000000000000019e-32Initial program 80.0%
times-frac97.6%
Simplified97.6%
Taylor expanded in t1 around 0 82.2%
associate-*r/82.2%
mul-1-neg82.2%
Simplified82.2%
if -5.49999999999999996e-58 < u < 7.60000000000000022e-88Initial program 67.8%
times-frac97.9%
Simplified97.9%
Taylor expanded in t1 around inf 86.5%
associate-*r/86.5%
neg-mul-186.5%
Simplified86.5%
if 4.70000000000000019e-32 < u < 9.5999999999999999e58Initial program 95.0%
associate-/r*99.8%
*-commutative99.8%
associate-/l*96.5%
associate-/l/96.5%
+-commutative96.5%
remove-double-neg96.5%
unsub-neg96.5%
div-sub96.5%
sub-neg96.5%
*-inverses96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in t1 around inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
if 9.5999999999999999e58 < u Initial program 84.9%
times-frac98.1%
Simplified98.1%
*-commutative98.1%
clear-num98.0%
frac-2neg98.0%
frac-times94.2%
*-un-lft-identity94.2%
remove-double-neg94.2%
distribute-neg-in94.2%
add-sqr-sqrt55.6%
sqrt-unprod90.4%
sqr-neg90.4%
sqrt-unprod34.8%
add-sqr-sqrt90.4%
sub-neg90.4%
Applied egg-rr90.4%
Taylor expanded in t1 around 0 90.4%
clear-num90.3%
inv-pow90.3%
*-commutative90.3%
associate-/l*93.8%
div-inv93.8%
clear-num93.9%
Applied egg-rr93.9%
unpow-193.9%
Simplified93.9%
Final simplification85.0%
(FPCore (u v t1)
:precision binary64
(if (<= u -8.2e-58)
(* (/ v (+ t1 u)) (/ (- t1) u))
(if (<= u 3.8e-88)
(/ (- v) t1)
(if (<= u 4e-31)
(/ v (* (+ t1 u) (/ (- t1 u) t1)))
(if (<= u 8.5e+58)
(/ v (- (* u -2.0) t1))
(/ 1.0 (/ (- t1 u) (* t1 (/ v u)))))))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -8.2e-58) {
tmp = (v / (t1 + u)) * (-t1 / u);
} else if (u <= 3.8e-88) {
tmp = -v / t1;
} else if (u <= 4e-31) {
tmp = v / ((t1 + u) * ((t1 - u) / t1));
} else if (u <= 8.5e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = 1.0 / ((t1 - u) / (t1 * (v / u)));
}
return tmp;
}
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.2d-58)) then
tmp = (v / (t1 + u)) * (-t1 / u)
else if (u <= 3.8d-88) then
tmp = -v / t1
else if (u <= 4d-31) then
tmp = v / ((t1 + u) * ((t1 - u) / t1))
else if (u <= 8.5d+58) then
tmp = v / ((u * (-2.0d0)) - t1)
else
tmp = 1.0d0 / ((t1 - u) / (t1 * (v / u)))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= -8.2e-58) {
tmp = (v / (t1 + u)) * (-t1 / u);
} else if (u <= 3.8e-88) {
tmp = -v / t1;
} else if (u <= 4e-31) {
tmp = v / ((t1 + u) * ((t1 - u) / t1));
} else if (u <= 8.5e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = 1.0 / ((t1 - u) / (t1 * (v / u)));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -8.2e-58: tmp = (v / (t1 + u)) * (-t1 / u) elif u <= 3.8e-88: tmp = -v / t1 elif u <= 4e-31: tmp = v / ((t1 + u) * ((t1 - u) / t1)) elif u <= 8.5e+58: tmp = v / ((u * -2.0) - t1) else: tmp = 1.0 / ((t1 - u) / (t1 * (v / u))) return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -8.2e-58) tmp = Float64(Float64(v / Float64(t1 + u)) * Float64(Float64(-t1) / u)); elseif (u <= 3.8e-88) tmp = Float64(Float64(-v) / t1); elseif (u <= 4e-31) tmp = Float64(v / Float64(Float64(t1 + u) * Float64(Float64(t1 - u) / t1))); elseif (u <= 8.5e+58) tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); else tmp = Float64(1.0 / Float64(Float64(t1 - u) / Float64(t1 * Float64(v / u)))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -8.2e-58) tmp = (v / (t1 + u)) * (-t1 / u); elseif (u <= 3.8e-88) tmp = -v / t1; elseif (u <= 4e-31) tmp = v / ((t1 + u) * ((t1 - u) / t1)); elseif (u <= 8.5e+58) tmp = v / ((u * -2.0) - t1); else tmp = 1.0 / ((t1 - u) / (t1 * (v / u))); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -8.2e-58], N[(N[(v / N[(t1 + u), $MachinePrecision]), $MachinePrecision] * N[((-t1) / u), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 3.8e-88], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 4e-31], N[(v / N[(N[(t1 + u), $MachinePrecision] * N[(N[(t1 - u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 8.5e+58], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(t1 - u), $MachinePrecision] / N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -8.2 \cdot 10^{-58}:\\
\;\;\;\;\frac{v}{t1 + u} \cdot \frac{-t1}{u}\\
\mathbf{elif}\;u \leq 3.8 \cdot 10^{-88}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 4 \cdot 10^{-31}:\\
\;\;\;\;\frac{v}{\left(t1 + u\right) \cdot \frac{t1 - u}{t1}}\\
\mathbf{elif}\;u \leq 8.5 \cdot 10^{+58}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{t1 - u}{t1 \cdot \frac{v}{u}}}\\
\end{array}
\end{array}
if u < -8.20000000000000056e-58Initial program 79.0%
times-frac98.5%
Simplified98.5%
Taylor expanded in t1 around 0 82.6%
associate-*r/82.6%
mul-1-neg82.6%
Simplified82.6%
if -8.20000000000000056e-58 < u < 3.80000000000000011e-88Initial program 67.8%
times-frac97.9%
Simplified97.9%
Taylor expanded in t1 around inf 86.5%
associate-*r/86.5%
neg-mul-186.5%
Simplified86.5%
if 3.80000000000000011e-88 < u < 4e-31Initial program 89.4%
times-frac89.2%
Simplified89.2%
clear-num89.3%
frac-times99.5%
*-un-lft-identity99.5%
frac-2neg99.5%
distribute-neg-in99.5%
add-sqr-sqrt77.4%
sqrt-unprod88.7%
sqr-neg88.7%
sqrt-unprod11.3%
add-sqr-sqrt88.7%
sub-neg88.7%
remove-double-neg88.7%
Applied egg-rr88.7%
if 4e-31 < u < 8.50000000000000015e58Initial program 95.0%
associate-/r*99.8%
*-commutative99.8%
associate-/l*96.5%
associate-/l/96.5%
+-commutative96.5%
remove-double-neg96.5%
unsub-neg96.5%
div-sub96.5%
sub-neg96.5%
*-inverses96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in t1 around inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
if 8.50000000000000015e58 < u Initial program 84.9%
times-frac98.1%
Simplified98.1%
*-commutative98.1%
clear-num98.0%
frac-2neg98.0%
frac-times94.2%
*-un-lft-identity94.2%
remove-double-neg94.2%
distribute-neg-in94.2%
add-sqr-sqrt55.6%
sqrt-unprod90.4%
sqr-neg90.4%
sqrt-unprod34.8%
add-sqr-sqrt90.4%
sub-neg90.4%
Applied egg-rr90.4%
Taylor expanded in t1 around 0 90.4%
clear-num90.3%
inv-pow90.3%
*-commutative90.3%
associate-/l*93.8%
div-inv93.8%
clear-num93.9%
Applied egg-rr93.9%
unpow-193.9%
Simplified93.9%
Final simplification85.3%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (/ (- t1 u) t1)))
(if (<= u -1.02e-55)
(/ (/ v t_1) (+ t1 u))
(if (<= u 2.1e-91)
(/ (- v) t1)
(if (<= u 4.7e-32)
(/ v (* (+ t1 u) t_1))
(if (<= u 8.5e+58)
(/ v (- (* u -2.0) t1))
(/ 1.0 (/ (- t1 u) (* t1 (/ v u))))))))))
double code(double u, double v, double t1) {
double t_1 = (t1 - u) / t1;
double tmp;
if (u <= -1.02e-55) {
tmp = (v / t_1) / (t1 + u);
} else if (u <= 2.1e-91) {
tmp = -v / t1;
} else if (u <= 4.7e-32) {
tmp = v / ((t1 + u) * t_1);
} else if (u <= 8.5e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = 1.0 / ((t1 - u) / (t1 * (v / u)));
}
return tmp;
}
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 - u) / t1
if (u <= (-1.02d-55)) then
tmp = (v / t_1) / (t1 + u)
else if (u <= 2.1d-91) then
tmp = -v / t1
else if (u <= 4.7d-32) then
tmp = v / ((t1 + u) * t_1)
else if (u <= 8.5d+58) then
tmp = v / ((u * (-2.0d0)) - t1)
else
tmp = 1.0d0 / ((t1 - u) / (t1 * (v / u)))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = (t1 - u) / t1;
double tmp;
if (u <= -1.02e-55) {
tmp = (v / t_1) / (t1 + u);
} else if (u <= 2.1e-91) {
tmp = -v / t1;
} else if (u <= 4.7e-32) {
tmp = v / ((t1 + u) * t_1);
} else if (u <= 8.5e+58) {
tmp = v / ((u * -2.0) - t1);
} else {
tmp = 1.0 / ((t1 - u) / (t1 * (v / u)));
}
return tmp;
}
def code(u, v, t1): t_1 = (t1 - u) / t1 tmp = 0 if u <= -1.02e-55: tmp = (v / t_1) / (t1 + u) elif u <= 2.1e-91: tmp = -v / t1 elif u <= 4.7e-32: tmp = v / ((t1 + u) * t_1) elif u <= 8.5e+58: tmp = v / ((u * -2.0) - t1) else: tmp = 1.0 / ((t1 - u) / (t1 * (v / u))) return tmp
function code(u, v, t1) t_1 = Float64(Float64(t1 - u) / t1) tmp = 0.0 if (u <= -1.02e-55) tmp = Float64(Float64(v / t_1) / Float64(t1 + u)); elseif (u <= 2.1e-91) tmp = Float64(Float64(-v) / t1); elseif (u <= 4.7e-32) tmp = Float64(v / Float64(Float64(t1 + u) * t_1)); elseif (u <= 8.5e+58) tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); else tmp = Float64(1.0 / Float64(Float64(t1 - u) / Float64(t1 * Float64(v / u)))); end return tmp end
function tmp_2 = code(u, v, t1) t_1 = (t1 - u) / t1; tmp = 0.0; if (u <= -1.02e-55) tmp = (v / t_1) / (t1 + u); elseif (u <= 2.1e-91) tmp = -v / t1; elseif (u <= 4.7e-32) tmp = v / ((t1 + u) * t_1); elseif (u <= 8.5e+58) tmp = v / ((u * -2.0) - t1); else tmp = 1.0 / ((t1 - u) / (t1 * (v / u))); end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(t1 - u), $MachinePrecision] / t1), $MachinePrecision]}, If[LessEqual[u, -1.02e-55], N[(N[(v / t$95$1), $MachinePrecision] / N[(t1 + u), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 2.1e-91], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 4.7e-32], N[(v / N[(N[(t1 + u), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 8.5e+58], N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(t1 - u), $MachinePrecision] / N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t1 - u}{t1}\\
\mathbf{if}\;u \leq -1.02 \cdot 10^{-55}:\\
\;\;\;\;\frac{\frac{v}{t_1}}{t1 + u}\\
\mathbf{elif}\;u \leq 2.1 \cdot 10^{-91}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 4.7 \cdot 10^{-32}:\\
\;\;\;\;\frac{v}{\left(t1 + u\right) \cdot t_1}\\
\mathbf{elif}\;u \leq 8.5 \cdot 10^{+58}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{t1 - u}{t1 \cdot \frac{v}{u}}}\\
\end{array}
\end{array}
if u < -1.02e-55Initial program 79.0%
times-frac98.5%
Simplified98.5%
associate-*r/99.2%
clear-num99.2%
associate-*l/99.2%
*-un-lft-identity99.2%
frac-2neg99.2%
distribute-neg-in99.2%
add-sqr-sqrt47.5%
sqrt-unprod83.5%
sqr-neg83.5%
sqrt-unprod44.1%
add-sqr-sqrt82.9%
sub-neg82.9%
remove-double-neg82.9%
Applied egg-rr82.9%
if -1.02e-55 < u < 2.0999999999999999e-91Initial program 67.8%
times-frac97.9%
Simplified97.9%
Taylor expanded in t1 around inf 86.5%
associate-*r/86.5%
neg-mul-186.5%
Simplified86.5%
if 2.0999999999999999e-91 < u < 4.70000000000000019e-32Initial program 89.4%
times-frac89.2%
Simplified89.2%
clear-num89.3%
frac-times99.5%
*-un-lft-identity99.5%
frac-2neg99.5%
distribute-neg-in99.5%
add-sqr-sqrt77.4%
sqrt-unprod88.7%
sqr-neg88.7%
sqrt-unprod11.3%
add-sqr-sqrt88.7%
sub-neg88.7%
remove-double-neg88.7%
Applied egg-rr88.7%
if 4.70000000000000019e-32 < u < 8.50000000000000015e58Initial program 95.0%
associate-/r*99.8%
*-commutative99.8%
associate-/l*96.5%
associate-/l/96.5%
+-commutative96.5%
remove-double-neg96.5%
unsub-neg96.5%
div-sub96.5%
sub-neg96.5%
*-inverses96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in t1 around inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
if 8.50000000000000015e58 < u Initial program 84.9%
times-frac98.1%
Simplified98.1%
*-commutative98.1%
clear-num98.0%
frac-2neg98.0%
frac-times94.2%
*-un-lft-identity94.2%
remove-double-neg94.2%
distribute-neg-in94.2%
add-sqr-sqrt55.6%
sqrt-unprod90.4%
sqr-neg90.4%
sqrt-unprod34.8%
add-sqr-sqrt90.4%
sub-neg90.4%
Applied egg-rr90.4%
Taylor expanded in t1 around 0 90.4%
clear-num90.3%
inv-pow90.3%
*-commutative90.3%
associate-/l*93.8%
div-inv93.8%
clear-num93.9%
Applied egg-rr93.9%
unpow-193.9%
Simplified93.9%
Final simplification85.4%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (* (/ v (+ t1 u)) (/ (- t1) u))))
(if (<= u -4.1e-57)
t_1
(if (<= u 7.6e-88)
(/ (- v) t1)
(if (or (<= u 2.35e-31) (not (<= u 8.5e+58)))
t_1
(/ v (- (* u -2.0) t1)))))))
double code(double u, double v, double t1) {
double t_1 = (v / (t1 + u)) * (-t1 / u);
double tmp;
if (u <= -4.1e-57) {
tmp = t_1;
} else if (u <= 7.6e-88) {
tmp = -v / t1;
} else if ((u <= 2.35e-31) || !(u <= 8.5e+58)) {
tmp = t_1;
} else {
tmp = v / ((u * -2.0) - t1);
}
return tmp;
}
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 + u)) * (-t1 / u)
if (u <= (-4.1d-57)) then
tmp = t_1
else if (u <= 7.6d-88) then
tmp = -v / t1
else if ((u <= 2.35d-31) .or. (.not. (u <= 8.5d+58))) then
tmp = t_1
else
tmp = v / ((u * (-2.0d0)) - t1)
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = (v / (t1 + u)) * (-t1 / u);
double tmp;
if (u <= -4.1e-57) {
tmp = t_1;
} else if (u <= 7.6e-88) {
tmp = -v / t1;
} else if ((u <= 2.35e-31) || !(u <= 8.5e+58)) {
tmp = t_1;
} else {
tmp = v / ((u * -2.0) - t1);
}
return tmp;
}
def code(u, v, t1): t_1 = (v / (t1 + u)) * (-t1 / u) tmp = 0 if u <= -4.1e-57: tmp = t_1 elif u <= 7.6e-88: tmp = -v / t1 elif (u <= 2.35e-31) or not (u <= 8.5e+58): tmp = t_1 else: tmp = v / ((u * -2.0) - t1) return tmp
function code(u, v, t1) t_1 = Float64(Float64(v / Float64(t1 + u)) * Float64(Float64(-t1) / u)) tmp = 0.0 if (u <= -4.1e-57) tmp = t_1; elseif (u <= 7.6e-88) tmp = Float64(Float64(-v) / t1); elseif ((u <= 2.35e-31) || !(u <= 8.5e+58)) tmp = t_1; else tmp = Float64(v / Float64(Float64(u * -2.0) - t1)); end return tmp end
function tmp_2 = code(u, v, t1) t_1 = (v / (t1 + u)) * (-t1 / u); tmp = 0.0; if (u <= -4.1e-57) tmp = t_1; elseif (u <= 7.6e-88) tmp = -v / t1; elseif ((u <= 2.35e-31) || ~((u <= 8.5e+58))) tmp = t_1; else tmp = v / ((u * -2.0) - t1); end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(v / N[(t1 + u), $MachinePrecision]), $MachinePrecision] * N[((-t1) / u), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -4.1e-57], t$95$1, If[LessEqual[u, 7.6e-88], N[((-v) / t1), $MachinePrecision], If[Or[LessEqual[u, 2.35e-31], N[Not[LessEqual[u, 8.5e+58]], $MachinePrecision]], t$95$1, N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{v}{t1 + u} \cdot \frac{-t1}{u}\\
\mathbf{if}\;u \leq -4.1 \cdot 10^{-57}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 7.6 \cdot 10^{-88}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 2.35 \cdot 10^{-31} \lor \neg \left(u \leq 8.5 \cdot 10^{+58}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u \cdot -2 - t1}\\
\end{array}
\end{array}
if u < -4.1000000000000001e-57 or 7.60000000000000022e-88 < u < 2.34999999999999993e-31 or 8.50000000000000015e58 < u Initial program 81.8%
times-frac97.8%
Simplified97.8%
Taylor expanded in t1 around 0 86.1%
associate-*r/86.1%
mul-1-neg86.1%
Simplified86.1%
if -4.1000000000000001e-57 < u < 7.60000000000000022e-88Initial program 67.8%
times-frac97.9%
Simplified97.9%
Taylor expanded in t1 around inf 86.5%
associate-*r/86.5%
neg-mul-186.5%
Simplified86.5%
if 2.34999999999999993e-31 < u < 8.50000000000000015e58Initial program 95.0%
associate-/r*99.8%
*-commutative99.8%
associate-/l*96.5%
associate-/l/96.5%
+-commutative96.5%
remove-double-neg96.5%
unsub-neg96.5%
div-sub96.5%
sub-neg96.5%
*-inverses96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in t1 around inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
Final simplification84.7%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (* v (/ (/ t1 u) (- t1 u)))) (t_2 (/ v (- (* u -2.0) t1))))
(if (<= t1 -3.5e-27)
t_2
(if (<= t1 4.5e-77)
t_1
(if (<= t1 7e-41)
t_2
(if (<= t1 7.6e-6) t_1 (/ (- v) (+ t1 (* u -2.0)))))))))
double code(double u, double v, double t1) {
double t_1 = v * ((t1 / u) / (t1 - u));
double t_2 = v / ((u * -2.0) - t1);
double tmp;
if (t1 <= -3.5e-27) {
tmp = t_2;
} else if (t1 <= 4.5e-77) {
tmp = t_1;
} else if (t1 <= 7e-41) {
tmp = t_2;
} else if (t1 <= 7.6e-6) {
tmp = t_1;
} else {
tmp = -v / (t1 + (u * -2.0));
}
return tmp;
}
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) :: t_2
real(8) :: tmp
t_1 = v * ((t1 / u) / (t1 - u))
t_2 = v / ((u * (-2.0d0)) - t1)
if (t1 <= (-3.5d-27)) then
tmp = t_2
else if (t1 <= 4.5d-77) then
tmp = t_1
else if (t1 <= 7d-41) then
tmp = t_2
else if (t1 <= 7.6d-6) then
tmp = t_1
else
tmp = -v / (t1 + (u * (-2.0d0)))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = v * ((t1 / u) / (t1 - u));
double t_2 = v / ((u * -2.0) - t1);
double tmp;
if (t1 <= -3.5e-27) {
tmp = t_2;
} else if (t1 <= 4.5e-77) {
tmp = t_1;
} else if (t1 <= 7e-41) {
tmp = t_2;
} else if (t1 <= 7.6e-6) {
tmp = t_1;
} else {
tmp = -v / (t1 + (u * -2.0));
}
return tmp;
}
def code(u, v, t1): t_1 = v * ((t1 / u) / (t1 - u)) t_2 = v / ((u * -2.0) - t1) tmp = 0 if t1 <= -3.5e-27: tmp = t_2 elif t1 <= 4.5e-77: tmp = t_1 elif t1 <= 7e-41: tmp = t_2 elif t1 <= 7.6e-6: tmp = t_1 else: tmp = -v / (t1 + (u * -2.0)) return tmp
function code(u, v, t1) t_1 = Float64(v * Float64(Float64(t1 / u) / Float64(t1 - u))) t_2 = Float64(v / Float64(Float64(u * -2.0) - t1)) tmp = 0.0 if (t1 <= -3.5e-27) tmp = t_2; elseif (t1 <= 4.5e-77) tmp = t_1; elseif (t1 <= 7e-41) tmp = t_2; elseif (t1 <= 7.6e-6) tmp = t_1; else tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * -2.0))); end return tmp end
function tmp_2 = code(u, v, t1) t_1 = v * ((t1 / u) / (t1 - u)); t_2 = v / ((u * -2.0) - t1); tmp = 0.0; if (t1 <= -3.5e-27) tmp = t_2; elseif (t1 <= 4.5e-77) tmp = t_1; elseif (t1 <= 7e-41) tmp = t_2; elseif (t1 <= 7.6e-6) tmp = t_1; else tmp = -v / (t1 + (u * -2.0)); end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(v * N[(N[(t1 / u), $MachinePrecision] / N[(t1 - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t1, -3.5e-27], t$95$2, If[LessEqual[t1, 4.5e-77], t$95$1, If[LessEqual[t1, 7e-41], t$95$2, If[LessEqual[t1, 7.6e-6], t$95$1, N[((-v) / N[(t1 + N[(u * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := v \cdot \frac{\frac{t1}{u}}{t1 - u}\\
t_2 := \frac{v}{u \cdot -2 - t1}\\
\mathbf{if}\;t1 \leq -3.5 \cdot 10^{-27}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t1 \leq 4.5 \cdot 10^{-77}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t1 \leq 7 \cdot 10^{-41}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t1 \leq 7.6 \cdot 10^{-6}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{t1 + u \cdot -2}\\
\end{array}
\end{array}
if t1 < -3.5000000000000001e-27 or 4.5000000000000001e-77 < t1 < 6.9999999999999999e-41Initial program 80.0%
associate-/r*88.0%
*-commutative88.0%
associate-/l*99.8%
associate-/l/97.2%
+-commutative97.2%
remove-double-neg97.2%
unsub-neg97.2%
div-sub97.2%
sub-neg97.2%
*-inverses97.2%
metadata-eval97.2%
Simplified97.2%
Taylor expanded in t1 around inf 78.2%
mul-1-neg78.2%
unsub-neg78.2%
*-commutative78.2%
Simplified78.2%
if -3.5000000000000001e-27 < t1 < 4.5000000000000001e-77 or 6.9999999999999999e-41 < t1 < 7.6000000000000001e-6Initial program 82.5%
times-frac95.3%
Simplified95.3%
*-commutative95.3%
clear-num95.2%
frac-2neg95.2%
frac-times89.1%
*-un-lft-identity89.1%
remove-double-neg89.1%
distribute-neg-in89.1%
add-sqr-sqrt47.7%
sqrt-unprod79.3%
sqr-neg79.3%
sqrt-unprod33.2%
add-sqr-sqrt70.3%
sub-neg70.3%
Applied egg-rr70.3%
Taylor expanded in t1 around 0 73.2%
Taylor expanded in v around 0 73.0%
associate-*l/71.9%
*-commutative71.9%
associate-/r*77.2%
Simplified77.2%
if 7.6000000000000001e-6 < t1 Initial program 65.8%
times-frac99.9%
Simplified99.9%
clear-num99.8%
frac-2neg99.8%
frac-times96.9%
*-un-lft-identity96.9%
frac-2neg96.9%
distribute-neg-in96.9%
add-sqr-sqrt0.0%
sqrt-unprod37.5%
sqr-neg37.5%
sqrt-unprod38.6%
add-sqr-sqrt38.6%
sub-neg38.6%
remove-double-neg38.6%
distribute-neg-in38.6%
add-sqr-sqrt0.0%
sqrt-unprod71.8%
sqr-neg71.8%
sqrt-unprod95.9%
add-sqr-sqrt96.3%
sub-neg96.3%
Applied egg-rr96.3%
associate-*l/68.8%
Simplified68.8%
Taylor expanded in t1 around inf 88.1%
*-commutative88.1%
Simplified88.1%
Final simplification80.1%
(FPCore (u v t1) :precision binary64 (* (/ v (+ t1 u)) (/ (- t1) (+ t1 u))))
double code(double u, double v, double t1) {
return (v / (t1 + u)) * (-t1 / (t1 + u));
}
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)) * (-t1 / (t1 + u))
end function
public static double code(double u, double v, double t1) {
return (v / (t1 + u)) * (-t1 / (t1 + u));
}
def code(u, v, t1): return (v / (t1 + u)) * (-t1 / (t1 + u))
function code(u, v, t1) return Float64(Float64(v / Float64(t1 + u)) * Float64(Float64(-t1) / Float64(t1 + u))) end
function tmp = code(u, v, t1) tmp = (v / (t1 + u)) * (-t1 / (t1 + u)); end
code[u_, v_, t1_] := N[(N[(v / N[(t1 + u), $MachinePrecision]), $MachinePrecision] * N[((-t1) / N[(t1 + u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{v}{t1 + u} \cdot \frac{-t1}{t1 + u}
\end{array}
Initial program 77.7%
times-frac97.7%
Simplified97.7%
Final simplification97.7%
(FPCore (u v t1) :precision binary64 (if (<= u -1.2e+194) (/ v u) (if (<= u 4.7e+126) (/ (- v) t1) (* v (/ t1 (* t1 u))))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -1.2e+194) {
tmp = v / u;
} else if (u <= 4.7e+126) {
tmp = -v / t1;
} else {
tmp = v * (t1 / (t1 * u));
}
return tmp;
}
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.2d+194)) then
tmp = v / u
else if (u <= 4.7d+126) then
tmp = -v / t1
else
tmp = v * (t1 / (t1 * u))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= -1.2e+194) {
tmp = v / u;
} else if (u <= 4.7e+126) {
tmp = -v / t1;
} else {
tmp = v * (t1 / (t1 * u));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -1.2e+194: tmp = v / u elif u <= 4.7e+126: tmp = -v / t1 else: tmp = v * (t1 / (t1 * u)) return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -1.2e+194) tmp = Float64(v / u); elseif (u <= 4.7e+126) tmp = Float64(Float64(-v) / t1); else tmp = Float64(v * Float64(t1 / Float64(t1 * u))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -1.2e+194) tmp = v / u; elseif (u <= 4.7e+126) tmp = -v / t1; else tmp = v * (t1 / (t1 * u)); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -1.2e+194], N[(v / u), $MachinePrecision], If[LessEqual[u, 4.7e+126], N[((-v) / t1), $MachinePrecision], N[(v * N[(t1 / N[(t1 * u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -1.2 \cdot 10^{+194}:\\
\;\;\;\;\frac{v}{u}\\
\mathbf{elif}\;u \leq 4.7 \cdot 10^{+126}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{else}:\\
\;\;\;\;v \cdot \frac{t1}{t1 \cdot u}\\
\end{array}
\end{array}
if u < -1.2e194Initial program 87.8%
times-frac99.6%
Simplified99.6%
*-commutative99.6%
clear-num99.6%
frac-2neg99.6%
frac-times92.8%
*-un-lft-identity92.8%
remove-double-neg92.8%
distribute-neg-in92.8%
add-sqr-sqrt42.3%
sqrt-unprod92.8%
sqr-neg92.8%
sqrt-unprod50.5%
add-sqr-sqrt92.8%
sub-neg92.8%
Applied egg-rr92.8%
Taylor expanded in t1 around 0 92.8%
Taylor expanded in t1 around inf 52.6%
if -1.2e194 < u < 4.6999999999999999e126Initial program 74.6%
times-frac97.0%
Simplified97.0%
Taylor expanded in t1 around inf 62.8%
associate-*r/62.8%
neg-mul-162.8%
Simplified62.8%
if 4.6999999999999999e126 < u Initial program 86.9%
times-frac99.9%
Simplified99.9%
*-commutative99.9%
clear-num99.9%
frac-2neg99.9%
frac-times96.9%
*-un-lft-identity96.9%
remove-double-neg96.9%
distribute-neg-in96.9%
add-sqr-sqrt61.7%
sqrt-unprod96.9%
sqr-neg96.9%
sqrt-unprod35.2%
add-sqr-sqrt96.9%
sub-neg96.9%
Applied egg-rr96.9%
Taylor expanded in t1 around 0 96.9%
Taylor expanded in u around 0 48.8%
associate-/r/46.8%
Applied egg-rr46.8%
Final simplification59.5%
(FPCore (u v t1) :precision binary64 (if (<= u -1.2e+194) (/ v u) (if (<= u 6e+127) (/ (- v) t1) (/ t1 (* t1 (/ u v))))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -1.2e+194) {
tmp = v / u;
} else if (u <= 6e+127) {
tmp = -v / t1;
} else {
tmp = t1 / (t1 * (u / v));
}
return tmp;
}
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.2d+194)) then
tmp = v / u
else if (u <= 6d+127) then
tmp = -v / t1
else
tmp = t1 / (t1 * (u / v))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= -1.2e+194) {
tmp = v / u;
} else if (u <= 6e+127) {
tmp = -v / t1;
} else {
tmp = t1 / (t1 * (u / v));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -1.2e+194: tmp = v / u elif u <= 6e+127: tmp = -v / t1 else: tmp = t1 / (t1 * (u / v)) return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -1.2e+194) tmp = Float64(v / u); elseif (u <= 6e+127) tmp = Float64(Float64(-v) / t1); else tmp = Float64(t1 / Float64(t1 * Float64(u / v))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -1.2e+194) tmp = v / u; elseif (u <= 6e+127) tmp = -v / t1; else tmp = t1 / (t1 * (u / v)); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -1.2e+194], N[(v / u), $MachinePrecision], If[LessEqual[u, 6e+127], N[((-v) / t1), $MachinePrecision], N[(t1 / N[(t1 * N[(u / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -1.2 \cdot 10^{+194}:\\
\;\;\;\;\frac{v}{u}\\
\mathbf{elif}\;u \leq 6 \cdot 10^{+127}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{t1}{t1 \cdot \frac{u}{v}}\\
\end{array}
\end{array}
if u < -1.2e194Initial program 87.8%
times-frac99.6%
Simplified99.6%
*-commutative99.6%
clear-num99.6%
frac-2neg99.6%
frac-times92.8%
*-un-lft-identity92.8%
remove-double-neg92.8%
distribute-neg-in92.8%
add-sqr-sqrt42.3%
sqrt-unprod92.8%
sqr-neg92.8%
sqrt-unprod50.5%
add-sqr-sqrt92.8%
sub-neg92.8%
Applied egg-rr92.8%
Taylor expanded in t1 around 0 92.8%
Taylor expanded in t1 around inf 52.6%
if -1.2e194 < u < 6.0000000000000005e127Initial program 74.6%
times-frac97.0%
Simplified97.0%
Taylor expanded in t1 around inf 62.8%
associate-*r/62.8%
neg-mul-162.8%
Simplified62.8%
if 6.0000000000000005e127 < u Initial program 86.9%
times-frac99.9%
Simplified99.9%
*-commutative99.9%
clear-num99.9%
frac-2neg99.9%
frac-times96.9%
*-un-lft-identity96.9%
remove-double-neg96.9%
distribute-neg-in96.9%
add-sqr-sqrt61.7%
sqrt-unprod96.9%
sqr-neg96.9%
sqrt-unprod35.2%
add-sqr-sqrt96.9%
sub-neg96.9%
Applied egg-rr96.9%
Taylor expanded in t1 around 0 96.9%
Taylor expanded in u around 0 48.8%
associate-*r/50.6%
Simplified50.6%
Final simplification60.0%
(FPCore (u v t1) :precision binary64 (if (<= u -1.3e+195) (/ v u) (if (<= u 2.9e+130) (/ (- v) t1) (/ (* v -0.5) u))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -1.3e+195) {
tmp = v / u;
} else if (u <= 2.9e+130) {
tmp = -v / t1;
} else {
tmp = (v * -0.5) / u;
}
return tmp;
}
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.3d+195)) then
tmp = v / u
else if (u <= 2.9d+130) then
tmp = -v / t1
else
tmp = (v * (-0.5d0)) / u
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= -1.3e+195) {
tmp = v / u;
} else if (u <= 2.9e+130) {
tmp = -v / t1;
} else {
tmp = (v * -0.5) / u;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -1.3e+195: tmp = v / u elif u <= 2.9e+130: tmp = -v / t1 else: tmp = (v * -0.5) / u return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -1.3e+195) tmp = Float64(v / u); elseif (u <= 2.9e+130) tmp = Float64(Float64(-v) / t1); else tmp = Float64(Float64(v * -0.5) / u); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -1.3e+195) tmp = v / u; elseif (u <= 2.9e+130) tmp = -v / t1; else tmp = (v * -0.5) / u; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -1.3e+195], N[(v / u), $MachinePrecision], If[LessEqual[u, 2.9e+130], N[((-v) / t1), $MachinePrecision], N[(N[(v * -0.5), $MachinePrecision] / u), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -1.3 \cdot 10^{+195}:\\
\;\;\;\;\frac{v}{u}\\
\mathbf{elif}\;u \leq 2.9 \cdot 10^{+130}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{v \cdot -0.5}{u}\\
\end{array}
\end{array}
if u < -1.30000000000000001e195Initial program 87.8%
times-frac99.6%
Simplified99.6%
*-commutative99.6%
clear-num99.6%
frac-2neg99.6%
frac-times92.8%
*-un-lft-identity92.8%
remove-double-neg92.8%
distribute-neg-in92.8%
add-sqr-sqrt42.3%
sqrt-unprod92.8%
sqr-neg92.8%
sqrt-unprod50.5%
add-sqr-sqrt92.8%
sub-neg92.8%
Applied egg-rr92.8%
Taylor expanded in t1 around 0 92.8%
Taylor expanded in t1 around inf 52.6%
if -1.30000000000000001e195 < u < 2.8999999999999999e130Initial program 74.6%
times-frac97.0%
Simplified97.0%
Taylor expanded in t1 around inf 62.8%
associate-*r/62.8%
neg-mul-162.8%
Simplified62.8%
if 2.8999999999999999e130 < u Initial program 86.9%
associate-/r*94.7%
*-commutative94.7%
associate-/l*100.0%
associate-/l/87.4%
+-commutative87.4%
remove-double-neg87.4%
unsub-neg87.4%
div-sub87.4%
sub-neg87.4%
*-inverses87.4%
metadata-eval87.4%
Simplified87.4%
Taylor expanded in t1 around inf 44.8%
mul-1-neg44.8%
unsub-neg44.8%
*-commutative44.8%
Simplified44.8%
Taylor expanded in u around inf 42.2%
associate-*r/42.2%
Simplified42.2%
Final simplification58.8%
(FPCore (u v t1) :precision binary64 (if (or (<= u -5.4e+195) (not (<= u 3.5e+126))) (/ v u) (/ (- v) t1)))
double code(double u, double v, double t1) {
double tmp;
if ((u <= -5.4e+195) || !(u <= 3.5e+126)) {
tmp = v / u;
} else {
tmp = -v / t1;
}
return tmp;
}
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.4d+195)) .or. (.not. (u <= 3.5d+126))) then
tmp = v / u
else
tmp = -v / t1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if ((u <= -5.4e+195) || !(u <= 3.5e+126)) {
tmp = v / u;
} else {
tmp = -v / t1;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (u <= -5.4e+195) or not (u <= 3.5e+126): tmp = v / u else: tmp = -v / t1 return tmp
function code(u, v, t1) tmp = 0.0 if ((u <= -5.4e+195) || !(u <= 3.5e+126)) tmp = Float64(v / u); else tmp = Float64(Float64(-v) / t1); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((u <= -5.4e+195) || ~((u <= 3.5e+126))) tmp = v / u; else tmp = -v / t1; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[u, -5.4e+195], N[Not[LessEqual[u, 3.5e+126]], $MachinePrecision]], N[(v / u), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -5.4 \cdot 10^{+195} \lor \neg \left(u \leq 3.5 \cdot 10^{+126}\right):\\
\;\;\;\;\frac{v}{u}\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{t1}\\
\end{array}
\end{array}
if u < -5.4000000000000003e195 or 3.5000000000000003e126 < u Initial program 87.2%
times-frac99.8%
Simplified99.8%
*-commutative99.8%
clear-num99.8%
frac-2neg99.8%
frac-times95.2%
*-un-lft-identity95.2%
remove-double-neg95.2%
distribute-neg-in95.2%
add-sqr-sqrt53.7%
sqrt-unprod95.2%
sqr-neg95.2%
sqrt-unprod41.5%
add-sqr-sqrt95.2%
sub-neg95.2%
Applied egg-rr95.2%
Taylor expanded in t1 around 0 95.2%
Taylor expanded in t1 around inf 46.5%
if -5.4000000000000003e195 < u < 3.5000000000000003e126Initial program 74.6%
times-frac97.0%
Simplified97.0%
Taylor expanded in t1 around inf 62.8%
associate-*r/62.8%
neg-mul-162.8%
Simplified62.8%
Final simplification58.8%
(FPCore (u v t1) :precision binary64 (if (or (<= t1 -6.7e+106) (not (<= t1 2.8e+105))) (/ v t1) (/ v u)))
double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -6.7e+106) || !(t1 <= 2.8e+105)) {
tmp = v / t1;
} else {
tmp = v / u;
}
return tmp;
}
real(8) function code(u, v, t1)
real(8), intent (in) :: u
real(8), intent (in) :: v
real(8), intent (in) :: t1
real(8) :: tmp
if ((t1 <= (-6.7d+106)) .or. (.not. (t1 <= 2.8d+105))) then
tmp = v / t1
else
tmp = v / u
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -6.7e+106) || !(t1 <= 2.8e+105)) {
tmp = v / t1;
} else {
tmp = v / u;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (t1 <= -6.7e+106) or not (t1 <= 2.8e+105): tmp = v / t1 else: tmp = v / u return tmp
function code(u, v, t1) tmp = 0.0 if ((t1 <= -6.7e+106) || !(t1 <= 2.8e+105)) tmp = Float64(v / t1); else tmp = Float64(v / u); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((t1 <= -6.7e+106) || ~((t1 <= 2.8e+105))) tmp = v / t1; else tmp = v / u; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[t1, -6.7e+106], N[Not[LessEqual[t1, 2.8e+105]], $MachinePrecision]], N[(v / t1), $MachinePrecision], N[(v / u), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -6.7 \cdot 10^{+106} \lor \neg \left(t1 \leq 2.8 \cdot 10^{+105}\right):\\
\;\;\;\;\frac{v}{t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u}\\
\end{array}
\end{array}
if t1 < -6.7e106 or 2.8000000000000001e105 < t1 Initial program 59.1%
times-frac99.9%
Simplified99.9%
*-commutative99.9%
clear-num99.6%
frac-2neg99.6%
frac-times68.0%
*-un-lft-identity68.0%
remove-double-neg68.0%
distribute-neg-in68.0%
add-sqr-sqrt32.9%
sqrt-unprod49.9%
sqr-neg49.9%
sqrt-unprod25.0%
add-sqr-sqrt48.3%
sub-neg48.3%
Applied egg-rr48.3%
Taylor expanded in t1 around inf 41.7%
if -6.7e106 < t1 < 2.8000000000000001e105Initial program 84.8%
times-frac96.9%
Simplified96.9%
*-commutative96.9%
clear-num96.7%
frac-2neg96.7%
frac-times89.8%
*-un-lft-identity89.8%
remove-double-neg89.8%
distribute-neg-in89.8%
add-sqr-sqrt46.7%
sqrt-unprod71.4%
sqr-neg71.4%
sqrt-unprod25.7%
add-sqr-sqrt57.6%
sub-neg57.6%
Applied egg-rr57.6%
Taylor expanded in t1 around 0 59.8%
Taylor expanded in t1 around inf 17.3%
Final simplification24.1%
(FPCore (u v t1) :precision binary64 (/ v (- (* u -2.0) t1)))
double code(double u, double v, double t1) {
return v / ((u * -2.0) - t1);
}
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
public static double code(double u, double v, double t1) {
return v / ((u * -2.0) - t1);
}
def code(u, v, t1): return v / ((u * -2.0) - t1)
function code(u, v, t1) return Float64(v / Float64(Float64(u * -2.0) - t1)) end
function tmp = code(u, v, t1) tmp = v / ((u * -2.0) - t1); end
code[u_, v_, t1_] := N[(v / N[(N[(u * -2.0), $MachinePrecision] - t1), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{v}{u \cdot -2 - t1}
\end{array}
Initial program 77.7%
associate-/r*87.6%
*-commutative87.6%
associate-/l*98.6%
associate-/l/95.4%
+-commutative95.4%
remove-double-neg95.4%
unsub-neg95.4%
div-sub95.4%
sub-neg95.4%
*-inverses95.4%
metadata-eval95.4%
Simplified95.4%
Taylor expanded in t1 around inf 60.4%
mul-1-neg60.4%
unsub-neg60.4%
*-commutative60.4%
Simplified60.4%
Final simplification60.4%
(FPCore (u v t1) :precision binary64 (/ v t1))
double code(double u, double v, double t1) {
return v / t1;
}
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
public static double code(double u, double v, double t1) {
return v / t1;
}
def code(u, v, t1): return v / t1
function code(u, v, t1) return Float64(v / t1) end
function tmp = code(u, v, t1) tmp = v / t1; end
code[u_, v_, t1_] := N[(v / t1), $MachinePrecision]
\begin{array}{l}
\\
\frac{v}{t1}
\end{array}
Initial program 77.7%
times-frac97.7%
Simplified97.7%
*-commutative97.7%
clear-num97.5%
frac-2neg97.5%
frac-times83.8%
*-un-lft-identity83.8%
remove-double-neg83.8%
distribute-neg-in83.8%
add-sqr-sqrt42.9%
sqrt-unprod65.4%
sqr-neg65.4%
sqrt-unprod25.5%
add-sqr-sqrt55.0%
sub-neg55.0%
Applied egg-rr55.0%
Taylor expanded in t1 around inf 13.9%
Final simplification13.9%
herbie shell --seed 2023331
(FPCore (u v t1)
:name "Rosa's DopplerBench"
:precision binary64
(/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))