
(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 15 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 (if (<= u -1.28e+70) (/ (* t1 (/ v u)) (- u)) (/ (- v) (+ t1 (* u (+ 2.0 (/ u t1)))))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -1.28e+70) {
tmp = (t1 * (v / u)) / -u;
} else {
tmp = -v / (t1 + (u * (2.0 + (u / 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 <= (-1.28d+70)) then
tmp = (t1 * (v / u)) / -u
else
tmp = -v / (t1 + (u * (2.0d0 + (u / t1))))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= -1.28e+70) {
tmp = (t1 * (v / u)) / -u;
} else {
tmp = -v / (t1 + (u * (2.0 + (u / t1))));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -1.28e+70: tmp = (t1 * (v / u)) / -u else: tmp = -v / (t1 + (u * (2.0 + (u / t1)))) return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -1.28e+70) tmp = Float64(Float64(t1 * Float64(v / u)) / Float64(-u)); else tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * Float64(2.0 + Float64(u / t1))))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -1.28e+70) tmp = (t1 * (v / u)) / -u; else tmp = -v / (t1 + (u * (2.0 + (u / t1)))); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -1.28e+70], N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / (-u)), $MachinePrecision], N[((-v) / N[(t1 + N[(u * N[(2.0 + N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -1.28 \cdot 10^{+70}:\\
\;\;\;\;\frac{t1 \cdot \frac{v}{u}}{-u}\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{t1 + u \cdot \left(2 + \frac{u}{t1}\right)}\\
\end{array}
\end{array}
if u < -1.27999999999999994e70Initial program 85.8%
associate-/l*83.6%
neg-mul-183.6%
*-commutative83.6%
associate-*r/83.6%
associate-/l*83.5%
neg-mul-183.5%
associate-/r*92.9%
Simplified92.9%
Taylor expanded in t1 around 0 83.5%
associate-*r/83.5%
neg-mul-183.5%
unpow283.5%
Simplified83.5%
associate-*r/84.3%
times-frac84.9%
add-sqr-sqrt53.6%
sqrt-unprod68.7%
sqr-neg68.7%
sqrt-unprod28.0%
add-sqr-sqrt64.7%
times-frac64.6%
associate-/l/64.4%
frac-2neg64.4%
distribute-neg-frac64.4%
distribute-rgt-neg-in64.4%
add-sqr-sqrt36.5%
sqrt-unprod59.9%
sqr-neg59.9%
sqrt-unprod33.5%
add-sqr-sqrt96.0%
Applied egg-rr96.1%
if -1.27999999999999994e70 < u Initial program 77.4%
*-commutative77.4%
times-frac95.7%
neg-mul-195.7%
associate-/l*95.3%
associate-*r/95.3%
associate-/l*95.3%
associate-/l/95.3%
neg-mul-195.3%
*-lft-identity95.3%
metadata-eval95.3%
times-frac95.3%
neg-mul-195.3%
remove-double-neg95.3%
neg-mul-195.3%
sub0-neg95.3%
associate--r+95.3%
neg-sub095.3%
div-sub95.3%
distribute-frac-neg95.3%
*-inverses95.3%
metadata-eval95.3%
Simplified95.3%
Taylor expanded in v around 0 97.5%
mul-1-neg97.5%
Simplified97.5%
distribute-rgt-in97.5%
*-un-lft-identity97.5%
associate-+l+97.5%
Applied egg-rr97.5%
Taylor expanded in u around 0 93.2%
+-commutative93.2%
*-commutative93.2%
unpow293.2%
associate-*r/97.5%
distribute-lft-out97.5%
Simplified97.5%
Final simplification97.3%
(FPCore (u v t1)
:precision binary64
(if (<= u -1.45e+19)
(/ (* t1 (/ v u)) (- u))
(if (<= u 3.3e-40)
(/ (- v) t1)
(if (<= u 1.4e-24)
(/ (- v) (/ (* u u) t1))
(if (<= u 1950000000000.0)
(/ (- v) (+ t1 (* u 2.0)))
(* t1 (/ (/ (- v) u) (+ u t1))))))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -1.45e+19) {
tmp = (t1 * (v / u)) / -u;
} else if (u <= 3.3e-40) {
tmp = -v / t1;
} else if (u <= 1.4e-24) {
tmp = -v / ((u * u) / t1);
} else if (u <= 1950000000000.0) {
tmp = -v / (t1 + (u * 2.0));
} else {
tmp = t1 * ((-v / u) / (u + 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 <= (-1.45d+19)) then
tmp = (t1 * (v / u)) / -u
else if (u <= 3.3d-40) then
tmp = -v / t1
else if (u <= 1.4d-24) then
tmp = -v / ((u * u) / t1)
else if (u <= 1950000000000.0d0) then
tmp = -v / (t1 + (u * 2.0d0))
else
tmp = t1 * ((-v / u) / (u + t1))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= -1.45e+19) {
tmp = (t1 * (v / u)) / -u;
} else if (u <= 3.3e-40) {
tmp = -v / t1;
} else if (u <= 1.4e-24) {
tmp = -v / ((u * u) / t1);
} else if (u <= 1950000000000.0) {
tmp = -v / (t1 + (u * 2.0));
} else {
tmp = t1 * ((-v / u) / (u + t1));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -1.45e+19: tmp = (t1 * (v / u)) / -u elif u <= 3.3e-40: tmp = -v / t1 elif u <= 1.4e-24: tmp = -v / ((u * u) / t1) elif u <= 1950000000000.0: tmp = -v / (t1 + (u * 2.0)) else: tmp = t1 * ((-v / u) / (u + t1)) return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -1.45e+19) tmp = Float64(Float64(t1 * Float64(v / u)) / Float64(-u)); elseif (u <= 3.3e-40) tmp = Float64(Float64(-v) / t1); elseif (u <= 1.4e-24) tmp = Float64(Float64(-v) / Float64(Float64(u * u) / t1)); elseif (u <= 1950000000000.0) tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * 2.0))); else tmp = Float64(t1 * Float64(Float64(Float64(-v) / u) / Float64(u + t1))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -1.45e+19) tmp = (t1 * (v / u)) / -u; elseif (u <= 3.3e-40) tmp = -v / t1; elseif (u <= 1.4e-24) tmp = -v / ((u * u) / t1); elseif (u <= 1950000000000.0) tmp = -v / (t1 + (u * 2.0)); else tmp = t1 * ((-v / u) / (u + t1)); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -1.45e+19], N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / (-u)), $MachinePrecision], If[LessEqual[u, 3.3e-40], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 1.4e-24], N[((-v) / N[(N[(u * u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1950000000000.0], N[((-v) / N[(t1 + N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t1 * N[(N[((-v) / u), $MachinePrecision] / N[(u + t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -1.45 \cdot 10^{+19}:\\
\;\;\;\;\frac{t1 \cdot \frac{v}{u}}{-u}\\
\mathbf{elif}\;u \leq 3.3 \cdot 10^{-40}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 1.4 \cdot 10^{-24}:\\
\;\;\;\;\frac{-v}{\frac{u \cdot u}{t1}}\\
\mathbf{elif}\;u \leq 1950000000000:\\
\;\;\;\;\frac{-v}{t1 + u \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;t1 \cdot \frac{\frac{-v}{u}}{u + t1}\\
\end{array}
\end{array}
if u < -1.45e19Initial program 85.1%
associate-/l*83.4%
neg-mul-183.4%
*-commutative83.4%
associate-*r/83.4%
associate-/l*83.4%
neg-mul-183.4%
associate-/r*90.7%
Simplified90.7%
Taylor expanded in t1 around 0 81.9%
associate-*r/81.9%
neg-mul-181.9%
unpow281.9%
Simplified81.9%
associate-*r/82.5%
times-frac81.7%
add-sqr-sqrt51.3%
sqrt-unprod65.3%
sqr-neg65.3%
sqrt-unprod24.0%
add-sqr-sqrt55.2%
times-frac55.2%
associate-/l/55.0%
frac-2neg55.0%
distribute-neg-frac55.0%
distribute-rgt-neg-in55.0%
add-sqr-sqrt31.0%
sqrt-unprod55.2%
sqr-neg55.2%
sqrt-unprod32.1%
add-sqr-sqrt91.7%
Applied egg-rr91.7%
if -1.45e19 < u < 3.29999999999999993e-40Initial program 74.5%
associate-/l*66.4%
neg-mul-166.4%
*-commutative66.4%
associate-*r/65.9%
associate-/l*66.0%
neg-mul-166.0%
associate-/r*73.5%
Simplified73.5%
Taylor expanded in t1 around inf 81.3%
associate-*r/81.3%
neg-mul-181.3%
Simplified81.3%
if 3.29999999999999993e-40 < u < 1.4000000000000001e-24Initial program 81.2%
*-commutative81.2%
times-frac81.0%
neg-mul-181.0%
associate-/l*81.3%
associate-*r/81.0%
associate-/l*81.0%
associate-/l/81.0%
neg-mul-181.0%
*-lft-identity81.0%
metadata-eval81.0%
times-frac81.0%
neg-mul-181.0%
remove-double-neg81.0%
neg-mul-181.0%
sub0-neg81.0%
associate--r+81.0%
neg-sub081.0%
div-sub81.0%
distribute-frac-neg81.0%
*-inverses81.0%
metadata-eval81.0%
Simplified81.0%
Taylor expanded in v around 0 99.4%
mul-1-neg99.4%
Simplified99.4%
Taylor expanded in t1 around 0 99.7%
unpow299.7%
Simplified99.7%
if 1.4000000000000001e-24 < u < 1.95e12Initial program 52.4%
*-commutative52.4%
times-frac99.7%
neg-mul-199.7%
associate-/l*99.7%
associate-*r/99.7%
associate-/l*99.7%
associate-/l/99.7%
neg-mul-199.7%
*-lft-identity99.7%
metadata-eval99.7%
times-frac99.7%
neg-mul-199.7%
remove-double-neg99.7%
neg-mul-199.7%
sub0-neg99.7%
associate--r+99.7%
neg-sub099.7%
div-sub99.7%
distribute-frac-neg99.7%
*-inverses99.7%
metadata-eval99.7%
Simplified99.7%
Taylor expanded in v around 0 100.0%
mul-1-neg100.0%
Simplified100.0%
Taylor expanded in t1 around inf 83.4%
*-commutative83.4%
Simplified83.4%
if 1.95e12 < u Initial program 85.2%
associate-/l*87.1%
neg-mul-187.1%
*-commutative87.1%
associate-*r/87.0%
associate-/l*87.4%
neg-mul-187.4%
associate-/r*89.2%
Simplified89.2%
Taylor expanded in t1 around 0 83.9%
associate-*r/83.9%
neg-mul-183.9%
Simplified83.9%
Final simplification84.4%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (/ (* t1 (/ v u)) (- u))))
(if (<= u -2.05e+18)
t_1
(if (<= u 1.1e-40)
(/ (- v) t1)
(if (<= u 1.25e+45)
(/ (- v) (/ (* u u) t1))
(if (<= u 1.8e+88) (/ (/ v t1) (- -1.0 (/ u t1))) t_1))))))
double code(double u, double v, double t1) {
double t_1 = (t1 * (v / u)) / -u;
double tmp;
if (u <= -2.05e+18) {
tmp = t_1;
} else if (u <= 1.1e-40) {
tmp = -v / t1;
} else if (u <= 1.25e+45) {
tmp = -v / ((u * u) / t1);
} else if (u <= 1.8e+88) {
tmp = (v / t1) / (-1.0 - (u / 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 = (t1 * (v / u)) / -u
if (u <= (-2.05d+18)) then
tmp = t_1
else if (u <= 1.1d-40) then
tmp = -v / t1
else if (u <= 1.25d+45) then
tmp = -v / ((u * u) / t1)
else if (u <= 1.8d+88) then
tmp = (v / t1) / ((-1.0d0) - (u / t1))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = (t1 * (v / u)) / -u;
double tmp;
if (u <= -2.05e+18) {
tmp = t_1;
} else if (u <= 1.1e-40) {
tmp = -v / t1;
} else if (u <= 1.25e+45) {
tmp = -v / ((u * u) / t1);
} else if (u <= 1.8e+88) {
tmp = (v / t1) / (-1.0 - (u / t1));
} else {
tmp = t_1;
}
return tmp;
}
def code(u, v, t1): t_1 = (t1 * (v / u)) / -u tmp = 0 if u <= -2.05e+18: tmp = t_1 elif u <= 1.1e-40: tmp = -v / t1 elif u <= 1.25e+45: tmp = -v / ((u * u) / t1) elif u <= 1.8e+88: tmp = (v / t1) / (-1.0 - (u / t1)) else: tmp = t_1 return tmp
function code(u, v, t1) t_1 = Float64(Float64(t1 * Float64(v / u)) / Float64(-u)) tmp = 0.0 if (u <= -2.05e+18) tmp = t_1; elseif (u <= 1.1e-40) tmp = Float64(Float64(-v) / t1); elseif (u <= 1.25e+45) tmp = Float64(Float64(-v) / Float64(Float64(u * u) / t1)); elseif (u <= 1.8e+88) tmp = Float64(Float64(v / t1) / Float64(-1.0 - Float64(u / t1))); else tmp = t_1; end return tmp end
function tmp_2 = code(u, v, t1) t_1 = (t1 * (v / u)) / -u; tmp = 0.0; if (u <= -2.05e+18) tmp = t_1; elseif (u <= 1.1e-40) tmp = -v / t1; elseif (u <= 1.25e+45) tmp = -v / ((u * u) / t1); elseif (u <= 1.8e+88) tmp = (v / t1) / (-1.0 - (u / t1)); else tmp = t_1; end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / (-u)), $MachinePrecision]}, If[LessEqual[u, -2.05e+18], t$95$1, If[LessEqual[u, 1.1e-40], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 1.25e+45], N[((-v) / N[(N[(u * u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.8e+88], N[(N[(v / t1), $MachinePrecision] / N[(-1.0 - N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t1 \cdot \frac{v}{u}}{-u}\\
\mathbf{if}\;u \leq -2.05 \cdot 10^{+18}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 1.1 \cdot 10^{-40}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 1.25 \cdot 10^{+45}:\\
\;\;\;\;\frac{-v}{\frac{u \cdot u}{t1}}\\
\mathbf{elif}\;u \leq 1.8 \cdot 10^{+88}:\\
\;\;\;\;\frac{\frac{v}{t1}}{-1 - \frac{u}{t1}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if u < -2.05e18 or 1.8000000000000001e88 < u Initial program 84.6%
associate-/l*84.8%
neg-mul-184.8%
*-commutative84.8%
associate-*r/84.8%
associate-/l*84.8%
neg-mul-184.8%
associate-/r*89.8%
Simplified89.8%
Taylor expanded in t1 around 0 84.0%
associate-*r/84.0%
neg-mul-184.0%
unpow284.0%
Simplified84.0%
associate-*r/82.1%
times-frac84.8%
add-sqr-sqrt47.5%
sqrt-unprod66.8%
sqr-neg66.8%
sqrt-unprod28.1%
add-sqr-sqrt60.4%
times-frac60.4%
associate-/l/60.2%
frac-2neg60.2%
distribute-neg-frac60.2%
distribute-rgt-neg-in60.2%
add-sqr-sqrt32.2%
sqrt-unprod64.0%
sqr-neg64.0%
sqrt-unprod38.2%
add-sqr-sqrt89.2%
Applied egg-rr91.4%
if -2.05e18 < u < 1.10000000000000004e-40Initial program 74.5%
associate-/l*66.4%
neg-mul-166.4%
*-commutative66.4%
associate-*r/65.9%
associate-/l*66.0%
neg-mul-166.0%
associate-/r*73.5%
Simplified73.5%
Taylor expanded in t1 around inf 81.3%
associate-*r/81.3%
neg-mul-181.3%
Simplified81.3%
if 1.10000000000000004e-40 < u < 1.25e45Initial program 76.2%
*-commutative76.2%
times-frac94.0%
neg-mul-194.0%
associate-/l*94.1%
associate-*r/93.8%
associate-/l*93.8%
associate-/l/93.8%
neg-mul-193.8%
*-lft-identity93.8%
metadata-eval93.8%
times-frac93.8%
neg-mul-193.8%
remove-double-neg93.8%
neg-mul-193.8%
sub0-neg93.8%
associate--r+93.8%
neg-sub093.8%
div-sub93.8%
distribute-frac-neg93.8%
*-inverses93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in v around 0 99.8%
mul-1-neg99.8%
Simplified99.8%
Taylor expanded in t1 around 0 70.4%
unpow270.4%
Simplified70.4%
if 1.25e45 < u < 1.8000000000000001e88Initial program 83.3%
*-commutative83.3%
times-frac100.0%
neg-mul-1100.0%
associate-/l*100.0%
associate-*r/100.0%
associate-/l*100.0%
associate-/l/100.0%
neg-mul-1100.0%
*-lft-identity100.0%
metadata-eval100.0%
times-frac100.0%
neg-mul-1100.0%
remove-double-neg100.0%
neg-mul-1100.0%
sub0-neg100.0%
associate--r+100.0%
neg-sub0100.0%
div-sub100.0%
distribute-frac-neg100.0%
*-inverses100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in t1 around inf 83.9%
Final simplification84.4%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (* t1 (/ (- v) (* u u)))))
(if (<= u -1.1e+19)
t_1
(if (<= u 3.5e-42)
(/ (- v) t1)
(if (<= u 8.5e+47)
(/ (- v) (/ (* u u) t1))
(if (<= u 8.5e+62) (/ (- v) (+ t1 (* u 2.0))) t_1))))))
double code(double u, double v, double t1) {
double t_1 = t1 * (-v / (u * u));
double tmp;
if (u <= -1.1e+19) {
tmp = t_1;
} else if (u <= 3.5e-42) {
tmp = -v / t1;
} else if (u <= 8.5e+47) {
tmp = -v / ((u * u) / t1);
} else if (u <= 8.5e+62) {
tmp = -v / (t1 + (u * 2.0));
} 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 = t1 * (-v / (u * u))
if (u <= (-1.1d+19)) then
tmp = t_1
else if (u <= 3.5d-42) then
tmp = -v / t1
else if (u <= 8.5d+47) then
tmp = -v / ((u * u) / t1)
else if (u <= 8.5d+62) then
tmp = -v / (t1 + (u * 2.0d0))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = t1 * (-v / (u * u));
double tmp;
if (u <= -1.1e+19) {
tmp = t_1;
} else if (u <= 3.5e-42) {
tmp = -v / t1;
} else if (u <= 8.5e+47) {
tmp = -v / ((u * u) / t1);
} else if (u <= 8.5e+62) {
tmp = -v / (t1 + (u * 2.0));
} else {
tmp = t_1;
}
return tmp;
}
def code(u, v, t1): t_1 = t1 * (-v / (u * u)) tmp = 0 if u <= -1.1e+19: tmp = t_1 elif u <= 3.5e-42: tmp = -v / t1 elif u <= 8.5e+47: tmp = -v / ((u * u) / t1) elif u <= 8.5e+62: tmp = -v / (t1 + (u * 2.0)) else: tmp = t_1 return tmp
function code(u, v, t1) t_1 = Float64(t1 * Float64(Float64(-v) / Float64(u * u))) tmp = 0.0 if (u <= -1.1e+19) tmp = t_1; elseif (u <= 3.5e-42) tmp = Float64(Float64(-v) / t1); elseif (u <= 8.5e+47) tmp = Float64(Float64(-v) / Float64(Float64(u * u) / t1)); elseif (u <= 8.5e+62) tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * 2.0))); else tmp = t_1; end return tmp end
function tmp_2 = code(u, v, t1) t_1 = t1 * (-v / (u * u)); tmp = 0.0; if (u <= -1.1e+19) tmp = t_1; elseif (u <= 3.5e-42) tmp = -v / t1; elseif (u <= 8.5e+47) tmp = -v / ((u * u) / t1); elseif (u <= 8.5e+62) tmp = -v / (t1 + (u * 2.0)); else tmp = t_1; end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(t1 * N[((-v) / N[(u * u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -1.1e+19], t$95$1, If[LessEqual[u, 3.5e-42], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 8.5e+47], N[((-v) / N[(N[(u * u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 8.5e+62], N[((-v) / N[(t1 + N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t1 \cdot \frac{-v}{u \cdot u}\\
\mathbf{if}\;u \leq -1.1 \cdot 10^{+19}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 3.5 \cdot 10^{-42}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 8.5 \cdot 10^{+47}:\\
\;\;\;\;\frac{-v}{\frac{u \cdot u}{t1}}\\
\mathbf{elif}\;u \leq 8.5 \cdot 10^{+62}:\\
\;\;\;\;\frac{-v}{t1 + u \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if u < -1.1e19 or 8.4999999999999997e62 < u Initial program 85.2%
associate-/l*85.4%
neg-mul-185.4%
*-commutative85.4%
associate-*r/85.4%
associate-/l*85.4%
neg-mul-185.4%
associate-/r*90.3%
Simplified90.3%
Taylor expanded in t1 around 0 82.7%
associate-*r/82.7%
neg-mul-182.7%
unpow282.7%
Simplified82.7%
if -1.1e19 < u < 3.5000000000000002e-42Initial program 74.5%
associate-/l*66.4%
neg-mul-166.4%
*-commutative66.4%
associate-*r/65.9%
associate-/l*66.0%
neg-mul-166.0%
associate-/r*73.5%
Simplified73.5%
Taylor expanded in t1 around inf 81.3%
associate-*r/81.3%
neg-mul-181.3%
Simplified81.3%
if 3.5000000000000002e-42 < u < 8.5000000000000008e47Initial program 76.2%
*-commutative76.2%
times-frac94.0%
neg-mul-194.0%
associate-/l*94.1%
associate-*r/93.8%
associate-/l*93.8%
associate-/l/93.8%
neg-mul-193.8%
*-lft-identity93.8%
metadata-eval93.8%
times-frac93.8%
neg-mul-193.8%
remove-double-neg93.8%
neg-mul-193.8%
sub0-neg93.8%
associate--r+93.8%
neg-sub093.8%
div-sub93.8%
distribute-frac-neg93.8%
*-inverses93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in v around 0 99.8%
mul-1-neg99.8%
Simplified99.8%
Taylor expanded in t1 around 0 70.4%
unpow270.4%
Simplified70.4%
if 8.5000000000000008e47 < u < 8.4999999999999997e62Initial program 75.1%
*-commutative75.1%
times-frac100.0%
neg-mul-1100.0%
associate-/l*100.0%
associate-*r/100.0%
associate-/l*100.0%
associate-/l/100.0%
neg-mul-1100.0%
*-lft-identity100.0%
metadata-eval100.0%
times-frac100.0%
neg-mul-1100.0%
remove-double-neg100.0%
neg-mul-1100.0%
sub0-neg100.0%
associate--r+100.0%
neg-sub0100.0%
div-sub100.0%
distribute-frac-neg100.0%
*-inverses100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in v around 0 99.8%
mul-1-neg99.8%
Simplified99.8%
Taylor expanded in t1 around inf 88.2%
*-commutative88.2%
Simplified88.2%
Final simplification81.4%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (* t1 (/ (/ (- v) u) u))))
(if (<= u -1.1e+21)
t_1
(if (<= u 8e-41)
(/ (- v) t1)
(if (<= u 1.16e+45)
(/ (- v) (/ (* u u) t1))
(if (<= u 1.05e+63) (/ (- v) (+ t1 (* u 2.0))) t_1))))))
double code(double u, double v, double t1) {
double t_1 = t1 * ((-v / u) / u);
double tmp;
if (u <= -1.1e+21) {
tmp = t_1;
} else if (u <= 8e-41) {
tmp = -v / t1;
} else if (u <= 1.16e+45) {
tmp = -v / ((u * u) / t1);
} else if (u <= 1.05e+63) {
tmp = -v / (t1 + (u * 2.0));
} 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 = t1 * ((-v / u) / u)
if (u <= (-1.1d+21)) then
tmp = t_1
else if (u <= 8d-41) then
tmp = -v / t1
else if (u <= 1.16d+45) then
tmp = -v / ((u * u) / t1)
else if (u <= 1.05d+63) then
tmp = -v / (t1 + (u * 2.0d0))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = t1 * ((-v / u) / u);
double tmp;
if (u <= -1.1e+21) {
tmp = t_1;
} else if (u <= 8e-41) {
tmp = -v / t1;
} else if (u <= 1.16e+45) {
tmp = -v / ((u * u) / t1);
} else if (u <= 1.05e+63) {
tmp = -v / (t1 + (u * 2.0));
} else {
tmp = t_1;
}
return tmp;
}
def code(u, v, t1): t_1 = t1 * ((-v / u) / u) tmp = 0 if u <= -1.1e+21: tmp = t_1 elif u <= 8e-41: tmp = -v / t1 elif u <= 1.16e+45: tmp = -v / ((u * u) / t1) elif u <= 1.05e+63: tmp = -v / (t1 + (u * 2.0)) else: tmp = t_1 return tmp
function code(u, v, t1) t_1 = Float64(t1 * Float64(Float64(Float64(-v) / u) / u)) tmp = 0.0 if (u <= -1.1e+21) tmp = t_1; elseif (u <= 8e-41) tmp = Float64(Float64(-v) / t1); elseif (u <= 1.16e+45) tmp = Float64(Float64(-v) / Float64(Float64(u * u) / t1)); elseif (u <= 1.05e+63) tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * 2.0))); else tmp = t_1; end return tmp end
function tmp_2 = code(u, v, t1) t_1 = t1 * ((-v / u) / u); tmp = 0.0; if (u <= -1.1e+21) tmp = t_1; elseif (u <= 8e-41) tmp = -v / t1; elseif (u <= 1.16e+45) tmp = -v / ((u * u) / t1); elseif (u <= 1.05e+63) tmp = -v / (t1 + (u * 2.0)); else tmp = t_1; end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(t1 * N[(N[((-v) / u), $MachinePrecision] / u), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[u, -1.1e+21], t$95$1, If[LessEqual[u, 8e-41], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 1.16e+45], N[((-v) / N[(N[(u * u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 1.05e+63], N[((-v) / N[(t1 + N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t1 \cdot \frac{\frac{-v}{u}}{u}\\
\mathbf{if}\;u \leq -1.1 \cdot 10^{+21}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 8 \cdot 10^{-41}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 1.16 \cdot 10^{+45}:\\
\;\;\;\;\frac{-v}{\frac{u \cdot u}{t1}}\\
\mathbf{elif}\;u \leq 1.05 \cdot 10^{+63}:\\
\;\;\;\;\frac{-v}{t1 + u \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if u < -1.1e21 or 1.0500000000000001e63 < u Initial program 85.2%
associate-/l*85.4%
neg-mul-185.4%
*-commutative85.4%
associate-*r/85.4%
associate-/l*85.4%
neg-mul-185.4%
associate-/r*90.3%
Simplified90.3%
Taylor expanded in t1 around 0 82.7%
associate-*r/82.7%
neg-mul-182.7%
unpow282.7%
Simplified82.7%
Taylor expanded in v around 0 82.7%
unpow282.7%
associate-/r*87.5%
associate-*r/87.5%
neg-mul-187.5%
distribute-neg-frac87.5%
Simplified87.5%
if -1.1e21 < u < 8.00000000000000005e-41Initial program 74.5%
associate-/l*66.4%
neg-mul-166.4%
*-commutative66.4%
associate-*r/65.9%
associate-/l*66.0%
neg-mul-166.0%
associate-/r*73.5%
Simplified73.5%
Taylor expanded in t1 around inf 81.3%
associate-*r/81.3%
neg-mul-181.3%
Simplified81.3%
if 8.00000000000000005e-41 < u < 1.1600000000000001e45Initial program 76.2%
*-commutative76.2%
times-frac94.0%
neg-mul-194.0%
associate-/l*94.1%
associate-*r/93.8%
associate-/l*93.8%
associate-/l/93.8%
neg-mul-193.8%
*-lft-identity93.8%
metadata-eval93.8%
times-frac93.8%
neg-mul-193.8%
remove-double-neg93.8%
neg-mul-193.8%
sub0-neg93.8%
associate--r+93.8%
neg-sub093.8%
div-sub93.8%
distribute-frac-neg93.8%
*-inverses93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in v around 0 99.8%
mul-1-neg99.8%
Simplified99.8%
Taylor expanded in t1 around 0 70.4%
unpow270.4%
Simplified70.4%
if 1.1600000000000001e45 < u < 1.0500000000000001e63Initial program 75.1%
*-commutative75.1%
times-frac100.0%
neg-mul-1100.0%
associate-/l*100.0%
associate-*r/100.0%
associate-/l*100.0%
associate-/l/100.0%
neg-mul-1100.0%
*-lft-identity100.0%
metadata-eval100.0%
times-frac100.0%
neg-mul-1100.0%
remove-double-neg100.0%
neg-mul-1100.0%
sub0-neg100.0%
associate--r+100.0%
neg-sub0100.0%
div-sub100.0%
distribute-frac-neg100.0%
*-inverses100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in v around 0 99.8%
mul-1-neg99.8%
Simplified99.8%
Taylor expanded in t1 around inf 88.2%
*-commutative88.2%
Simplified88.2%
Final simplification83.2%
(FPCore (u v t1)
:precision binary64
(let* ((t_1 (/ (* t1 (/ v u)) (- u))))
(if (<= u -1.4e+18)
t_1
(if (<= u 1.4e-42)
(/ (- v) t1)
(if (<= u 1.35e+48)
(/ (- v) (/ (* u u) t1))
(if (<= u 7.6e+66) (/ (- v) (+ t1 (* u 2.0))) t_1))))))
double code(double u, double v, double t1) {
double t_1 = (t1 * (v / u)) / -u;
double tmp;
if (u <= -1.4e+18) {
tmp = t_1;
} else if (u <= 1.4e-42) {
tmp = -v / t1;
} else if (u <= 1.35e+48) {
tmp = -v / ((u * u) / t1);
} else if (u <= 7.6e+66) {
tmp = -v / (t1 + (u * 2.0));
} 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 = (t1 * (v / u)) / -u
if (u <= (-1.4d+18)) then
tmp = t_1
else if (u <= 1.4d-42) then
tmp = -v / t1
else if (u <= 1.35d+48) then
tmp = -v / ((u * u) / t1)
else if (u <= 7.6d+66) then
tmp = -v / (t1 + (u * 2.0d0))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double t_1 = (t1 * (v / u)) / -u;
double tmp;
if (u <= -1.4e+18) {
tmp = t_1;
} else if (u <= 1.4e-42) {
tmp = -v / t1;
} else if (u <= 1.35e+48) {
tmp = -v / ((u * u) / t1);
} else if (u <= 7.6e+66) {
tmp = -v / (t1 + (u * 2.0));
} else {
tmp = t_1;
}
return tmp;
}
def code(u, v, t1): t_1 = (t1 * (v / u)) / -u tmp = 0 if u <= -1.4e+18: tmp = t_1 elif u <= 1.4e-42: tmp = -v / t1 elif u <= 1.35e+48: tmp = -v / ((u * u) / t1) elif u <= 7.6e+66: tmp = -v / (t1 + (u * 2.0)) else: tmp = t_1 return tmp
function code(u, v, t1) t_1 = Float64(Float64(t1 * Float64(v / u)) / Float64(-u)) tmp = 0.0 if (u <= -1.4e+18) tmp = t_1; elseif (u <= 1.4e-42) tmp = Float64(Float64(-v) / t1); elseif (u <= 1.35e+48) tmp = Float64(Float64(-v) / Float64(Float64(u * u) / t1)); elseif (u <= 7.6e+66) tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * 2.0))); else tmp = t_1; end return tmp end
function tmp_2 = code(u, v, t1) t_1 = (t1 * (v / u)) / -u; tmp = 0.0; if (u <= -1.4e+18) tmp = t_1; elseif (u <= 1.4e-42) tmp = -v / t1; elseif (u <= 1.35e+48) tmp = -v / ((u * u) / t1); elseif (u <= 7.6e+66) tmp = -v / (t1 + (u * 2.0)); else tmp = t_1; end tmp_2 = tmp; end
code[u_, v_, t1_] := Block[{t$95$1 = N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / (-u)), $MachinePrecision]}, If[LessEqual[u, -1.4e+18], t$95$1, If[LessEqual[u, 1.4e-42], N[((-v) / t1), $MachinePrecision], If[LessEqual[u, 1.35e+48], N[((-v) / N[(N[(u * u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision], If[LessEqual[u, 7.6e+66], N[((-v) / N[(t1 + N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t1 \cdot \frac{v}{u}}{-u}\\
\mathbf{if}\;u \leq -1.4 \cdot 10^{+18}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;u \leq 1.4 \cdot 10^{-42}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{elif}\;u \leq 1.35 \cdot 10^{+48}:\\
\;\;\;\;\frac{-v}{\frac{u \cdot u}{t1}}\\
\mathbf{elif}\;u \leq 7.6 \cdot 10^{+66}:\\
\;\;\;\;\frac{-v}{t1 + u \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if u < -1.4e18 or 7.6000000000000004e66 < u Initial program 85.2%
associate-/l*85.4%
neg-mul-185.4%
*-commutative85.4%
associate-*r/85.4%
associate-/l*85.4%
neg-mul-185.4%
associate-/r*90.3%
Simplified90.3%
Taylor expanded in t1 around 0 82.7%
associate-*r/82.7%
neg-mul-182.7%
unpow282.7%
Simplified82.7%
associate-*r/80.9%
times-frac83.5%
add-sqr-sqrt46.6%
sqrt-unprod66.2%
sqr-neg66.2%
sqrt-unprod27.9%
add-sqr-sqrt59.0%
times-frac59.0%
associate-/l/58.9%
frac-2neg58.9%
distribute-neg-frac58.9%
distribute-rgt-neg-in58.9%
add-sqr-sqrt31.0%
sqrt-unprod62.5%
sqr-neg62.5%
sqrt-unprod37.7%
add-sqr-sqrt87.7%
Applied egg-rr89.8%
if -1.4e18 < u < 1.39999999999999999e-42Initial program 74.5%
associate-/l*66.4%
neg-mul-166.4%
*-commutative66.4%
associate-*r/65.9%
associate-/l*66.0%
neg-mul-166.0%
associate-/r*73.5%
Simplified73.5%
Taylor expanded in t1 around inf 81.3%
associate-*r/81.3%
neg-mul-181.3%
Simplified81.3%
if 1.39999999999999999e-42 < u < 1.35000000000000002e48Initial program 76.2%
*-commutative76.2%
times-frac94.0%
neg-mul-194.0%
associate-/l*94.1%
associate-*r/93.8%
associate-/l*93.8%
associate-/l/93.8%
neg-mul-193.8%
*-lft-identity93.8%
metadata-eval93.8%
times-frac93.8%
neg-mul-193.8%
remove-double-neg93.8%
neg-mul-193.8%
sub0-neg93.8%
associate--r+93.8%
neg-sub093.8%
div-sub93.8%
distribute-frac-neg93.8%
*-inverses93.8%
metadata-eval93.8%
Simplified93.8%
Taylor expanded in v around 0 99.8%
mul-1-neg99.8%
Simplified99.8%
Taylor expanded in t1 around 0 70.4%
unpow270.4%
Simplified70.4%
if 1.35000000000000002e48 < u < 7.6000000000000004e66Initial program 75.1%
*-commutative75.1%
times-frac100.0%
neg-mul-1100.0%
associate-/l*100.0%
associate-*r/100.0%
associate-/l*100.0%
associate-/l/100.0%
neg-mul-1100.0%
*-lft-identity100.0%
metadata-eval100.0%
times-frac100.0%
neg-mul-1100.0%
remove-double-neg100.0%
neg-mul-1100.0%
sub0-neg100.0%
associate--r+100.0%
neg-sub0100.0%
div-sub100.0%
distribute-frac-neg100.0%
*-inverses100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in v around 0 99.8%
mul-1-neg99.8%
Simplified99.8%
Taylor expanded in t1 around inf 88.2%
*-commutative88.2%
Simplified88.2%
Final simplification84.0%
(FPCore (u v t1) :precision binary64 (if (<= u -2.65e+70) (/ (* t1 (/ v u)) (- u)) (/ (- v) (* (+ u t1) (+ (/ u t1) 1.0)))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -2.65e+70) {
tmp = (t1 * (v / u)) / -u;
} else {
tmp = -v / ((u + t1) * ((u / t1) + 1.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) :: tmp
if (u <= (-2.65d+70)) then
tmp = (t1 * (v / u)) / -u
else
tmp = -v / ((u + t1) * ((u / t1) + 1.0d0))
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= -2.65e+70) {
tmp = (t1 * (v / u)) / -u;
} else {
tmp = -v / ((u + t1) * ((u / t1) + 1.0));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -2.65e+70: tmp = (t1 * (v / u)) / -u else: tmp = -v / ((u + t1) * ((u / t1) + 1.0)) return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -2.65e+70) tmp = Float64(Float64(t1 * Float64(v / u)) / Float64(-u)); else tmp = Float64(Float64(-v) / Float64(Float64(u + t1) * Float64(Float64(u / t1) + 1.0))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -2.65e+70) tmp = (t1 * (v / u)) / -u; else tmp = -v / ((u + t1) * ((u / t1) + 1.0)); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -2.65e+70], N[(N[(t1 * N[(v / u), $MachinePrecision]), $MachinePrecision] / (-u)), $MachinePrecision], N[((-v) / N[(N[(u + t1), $MachinePrecision] * N[(N[(u / t1), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -2.65 \cdot 10^{+70}:\\
\;\;\;\;\frac{t1 \cdot \frac{v}{u}}{-u}\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{\left(u + t1\right) \cdot \left(\frac{u}{t1} + 1\right)}\\
\end{array}
\end{array}
if u < -2.65e70Initial program 85.8%
associate-/l*83.6%
neg-mul-183.6%
*-commutative83.6%
associate-*r/83.6%
associate-/l*83.5%
neg-mul-183.5%
associate-/r*92.9%
Simplified92.9%
Taylor expanded in t1 around 0 83.5%
associate-*r/83.5%
neg-mul-183.5%
unpow283.5%
Simplified83.5%
associate-*r/84.3%
times-frac84.9%
add-sqr-sqrt53.6%
sqrt-unprod68.7%
sqr-neg68.7%
sqrt-unprod28.0%
add-sqr-sqrt64.7%
times-frac64.6%
associate-/l/64.4%
frac-2neg64.4%
distribute-neg-frac64.4%
distribute-rgt-neg-in64.4%
add-sqr-sqrt36.5%
sqrt-unprod59.9%
sqr-neg59.9%
sqrt-unprod33.5%
add-sqr-sqrt96.0%
Applied egg-rr96.1%
if -2.65e70 < u Initial program 77.4%
*-commutative77.4%
times-frac95.7%
neg-mul-195.7%
associate-/l*95.3%
associate-*r/95.3%
associate-/l*95.3%
associate-/l/95.3%
neg-mul-195.3%
*-lft-identity95.3%
metadata-eval95.3%
times-frac95.3%
neg-mul-195.3%
remove-double-neg95.3%
neg-mul-195.3%
sub0-neg95.3%
associate--r+95.3%
neg-sub095.3%
div-sub95.3%
distribute-frac-neg95.3%
*-inverses95.3%
metadata-eval95.3%
Simplified95.3%
Taylor expanded in v around 0 97.5%
mul-1-neg97.5%
Simplified97.5%
Final simplification97.3%
(FPCore (u v t1) :precision binary64 (if (or (<= t1 -1.2e-55) (not (<= t1 8e-9))) (/ (- v) (+ t1 (* u 2.0))) (/ (- v) (/ (* u u) t1))))
double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -1.2e-55) || !(t1 <= 8e-9)) {
tmp = -v / (t1 + (u * 2.0));
} else {
tmp = -v / ((u * u) / 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 ((t1 <= (-1.2d-55)) .or. (.not. (t1 <= 8d-9))) then
tmp = -v / (t1 + (u * 2.0d0))
else
tmp = -v / ((u * u) / t1)
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -1.2e-55) || !(t1 <= 8e-9)) {
tmp = -v / (t1 + (u * 2.0));
} else {
tmp = -v / ((u * u) / t1);
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (t1 <= -1.2e-55) or not (t1 <= 8e-9): tmp = -v / (t1 + (u * 2.0)) else: tmp = -v / ((u * u) / t1) return tmp
function code(u, v, t1) tmp = 0.0 if ((t1 <= -1.2e-55) || !(t1 <= 8e-9)) tmp = Float64(Float64(-v) / Float64(t1 + Float64(u * 2.0))); else tmp = Float64(Float64(-v) / Float64(Float64(u * u) / t1)); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((t1 <= -1.2e-55) || ~((t1 <= 8e-9))) tmp = -v / (t1 + (u * 2.0)); else tmp = -v / ((u * u) / t1); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.2e-55], N[Not[LessEqual[t1, 8e-9]], $MachinePrecision]], N[((-v) / N[(t1 + N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-v) / N[(N[(u * u), $MachinePrecision] / t1), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -1.2 \cdot 10^{-55} \lor \neg \left(t1 \leq 8 \cdot 10^{-9}\right):\\
\;\;\;\;\frac{-v}{t1 + u \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{\frac{u \cdot u}{t1}}\\
\end{array}
\end{array}
if t1 < -1.19999999999999996e-55 or 8.0000000000000005e-9 < t1 Initial program 71.6%
*-commutative71.6%
times-frac99.9%
neg-mul-199.9%
associate-/l*99.9%
associate-*r/99.9%
associate-/l*99.9%
associate-/l/99.9%
neg-mul-199.9%
*-lft-identity99.9%
metadata-eval99.9%
times-frac99.9%
neg-mul-199.9%
remove-double-neg99.9%
neg-mul-199.9%
sub0-neg99.9%
associate--r+99.9%
neg-sub099.9%
div-sub99.9%
distribute-frac-neg99.9%
*-inverses99.9%
metadata-eval99.9%
Simplified99.9%
Taylor expanded in v around 0 97.9%
mul-1-neg97.9%
Simplified97.9%
Taylor expanded in t1 around inf 83.4%
*-commutative83.4%
Simplified83.4%
if -1.19999999999999996e-55 < t1 < 8.0000000000000005e-9Initial program 86.9%
*-commutative86.9%
times-frac88.4%
neg-mul-188.4%
associate-/l*87.8%
associate-*r/87.8%
associate-/l*87.8%
associate-/l/87.8%
neg-mul-187.8%
*-lft-identity87.8%
metadata-eval87.8%
times-frac87.8%
neg-mul-187.8%
remove-double-neg87.8%
neg-mul-187.8%
sub0-neg87.8%
associate--r+87.8%
neg-sub087.8%
div-sub87.8%
distribute-frac-neg87.8%
*-inverses87.8%
metadata-eval87.8%
Simplified87.8%
Taylor expanded in v around 0 90.9%
mul-1-neg90.9%
Simplified90.9%
Taylor expanded in t1 around 0 71.4%
unpow271.4%
Simplified71.4%
Final simplification77.8%
(FPCore (u v t1) :precision binary64 (if (or (<= u -3.25e+38) (not (<= u 6.2e+76))) (* (/ v u) (/ t1 u)) (/ (- v) t1)))
double code(double u, double v, double t1) {
double tmp;
if ((u <= -3.25e+38) || !(u <= 6.2e+76)) {
tmp = (v / u) * (t1 / 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 <= (-3.25d+38)) .or. (.not. (u <= 6.2d+76))) then
tmp = (v / u) * (t1 / 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 <= -3.25e+38) || !(u <= 6.2e+76)) {
tmp = (v / u) * (t1 / u);
} else {
tmp = -v / t1;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (u <= -3.25e+38) or not (u <= 6.2e+76): tmp = (v / u) * (t1 / u) else: tmp = -v / t1 return tmp
function code(u, v, t1) tmp = 0.0 if ((u <= -3.25e+38) || !(u <= 6.2e+76)) tmp = Float64(Float64(v / u) * Float64(t1 / u)); else tmp = Float64(Float64(-v) / t1); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((u <= -3.25e+38) || ~((u <= 6.2e+76))) tmp = (v / u) * (t1 / u); else tmp = -v / t1; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[u, -3.25e+38], N[Not[LessEqual[u, 6.2e+76]], $MachinePrecision]], N[(N[(v / u), $MachinePrecision] * N[(t1 / u), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -3.25 \cdot 10^{+38} \lor \neg \left(u \leq 6.2 \cdot 10^{+76}\right):\\
\;\;\;\;\frac{v}{u} \cdot \frac{t1}{u}\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{t1}\\
\end{array}
\end{array}
if u < -3.25e38 or 6.20000000000000023e76 < u Initial program 85.1%
Taylor expanded in t1 around 0 81.6%
unpow281.6%
Simplified81.6%
*-commutative81.6%
times-frac85.0%
add-sqr-sqrt41.6%
sqrt-unprod66.1%
sqr-neg66.1%
sqrt-unprod33.4%
add-sqr-sqrt63.3%
Applied egg-rr63.3%
if -3.25e38 < u < 6.20000000000000023e76Initial program 75.3%
associate-/l*68.2%
neg-mul-168.2%
*-commutative68.2%
associate-*r/67.8%
associate-/l*68.5%
neg-mul-168.5%
associate-/r*75.5%
Simplified75.5%
Taylor expanded in t1 around inf 74.0%
associate-*r/74.0%
neg-mul-174.0%
Simplified74.0%
Final simplification70.2%
(FPCore (u v t1) :precision binary64 (if (or (<= u -3e+38) (not (<= u 1.75e+77))) (/ v (* u (/ u t1))) (/ (- v) t1)))
double code(double u, double v, double t1) {
double tmp;
if ((u <= -3e+38) || !(u <= 1.75e+77)) {
tmp = v / (u * (u / t1));
} 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 <= (-3d+38)) .or. (.not. (u <= 1.75d+77))) then
tmp = v / (u * (u / t1))
else
tmp = -v / t1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if ((u <= -3e+38) || !(u <= 1.75e+77)) {
tmp = v / (u * (u / t1));
} else {
tmp = -v / t1;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (u <= -3e+38) or not (u <= 1.75e+77): tmp = v / (u * (u / t1)) else: tmp = -v / t1 return tmp
function code(u, v, t1) tmp = 0.0 if ((u <= -3e+38) || !(u <= 1.75e+77)) tmp = Float64(v / Float64(u * Float64(u / t1))); else tmp = Float64(Float64(-v) / t1); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((u <= -3e+38) || ~((u <= 1.75e+77))) tmp = v / (u * (u / t1)); else tmp = -v / t1; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[u, -3e+38], N[Not[LessEqual[u, 1.75e+77]], $MachinePrecision]], N[(v / N[(u * N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[((-v) / t1), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -3 \cdot 10^{+38} \lor \neg \left(u \leq 1.75 \cdot 10^{+77}\right):\\
\;\;\;\;\frac{v}{u \cdot \frac{u}{t1}}\\
\mathbf{else}:\\
\;\;\;\;\frac{-v}{t1}\\
\end{array}
\end{array}
if u < -3.0000000000000001e38 or 1.7500000000000001e77 < u Initial program 85.1%
associate-/l*85.3%
neg-mul-185.3%
*-commutative85.3%
associate-*r/85.2%
associate-/l*85.3%
neg-mul-185.3%
associate-/r*90.5%
Simplified90.5%
associate-/l/85.3%
associate-*r/85.1%
distribute-rgt-neg-in85.1%
distribute-lft-neg-out85.1%
associate-/r*94.4%
Applied egg-rr93.0%
*-rgt-identity93.0%
associate-/r/86.9%
times-frac79.2%
/-rgt-identity79.2%
Simplified79.2%
Taylor expanded in t1 around 0 72.9%
associate-*r/72.9%
mul-1-neg72.9%
unpow272.9%
Simplified72.9%
*-commutative72.9%
clear-num72.9%
un-div-inv72.9%
add-sqr-sqrt33.3%
sqrt-unprod59.8%
sqr-neg59.8%
sqrt-unprod33.6%
add-sqr-sqrt63.6%
associate-*r/63.5%
Applied egg-rr63.5%
if -3.0000000000000001e38 < u < 1.7500000000000001e77Initial program 75.3%
associate-/l*68.2%
neg-mul-168.2%
*-commutative68.2%
associate-*r/67.8%
associate-/l*68.5%
neg-mul-168.5%
associate-/r*75.5%
Simplified75.5%
Taylor expanded in t1 around inf 74.0%
associate-*r/74.0%
neg-mul-174.0%
Simplified74.0%
Final simplification70.3%
(FPCore (u v t1) :precision binary64 (/ (/ v (+ u t1)) (- -1.0 (/ u t1))))
double code(double u, double v, double t1) {
return (v / (u + t1)) / (-1.0 - (u / 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 + t1)) / ((-1.0d0) - (u / t1))
end function
public static double code(double u, double v, double t1) {
return (v / (u + t1)) / (-1.0 - (u / t1));
}
def code(u, v, t1): return (v / (u + t1)) / (-1.0 - (u / t1))
function code(u, v, t1) return Float64(Float64(v / Float64(u + t1)) / Float64(-1.0 - Float64(u / t1))) end
function tmp = code(u, v, t1) tmp = (v / (u + t1)) / (-1.0 - (u / t1)); end
code[u_, v_, t1_] := N[(N[(v / N[(u + t1), $MachinePrecision]), $MachinePrecision] / N[(-1.0 - N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{v}{u + t1}}{-1 - \frac{u}{t1}}
\end{array}
Initial program 78.7%
*-commutative78.7%
times-frac94.6%
neg-mul-194.6%
associate-/l*94.3%
associate-*r/94.3%
associate-/l*94.3%
associate-/l/94.3%
neg-mul-194.3%
*-lft-identity94.3%
metadata-eval94.3%
times-frac94.3%
neg-mul-194.3%
remove-double-neg94.3%
neg-mul-194.3%
sub0-neg94.3%
associate--r+94.3%
neg-sub094.3%
div-sub94.3%
distribute-frac-neg94.3%
*-inverses94.3%
metadata-eval94.3%
Simplified94.3%
Final simplification94.3%
(FPCore (u v t1) :precision binary64 (if (<= u -6e+69) (/ v u) (if (<= u 1.35e+221) (/ (- v) t1) (/ v u))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -6e+69) {
tmp = v / u;
} else if (u <= 1.35e+221) {
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 (u <= (-6d+69)) then
tmp = v / u
else if (u <= 1.35d+221) 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 (u <= -6e+69) {
tmp = v / u;
} else if (u <= 1.35e+221) {
tmp = -v / t1;
} else {
tmp = v / u;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -6e+69: tmp = v / u elif u <= 1.35e+221: tmp = -v / t1 else: tmp = v / u return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -6e+69) tmp = Float64(v / u); elseif (u <= 1.35e+221) tmp = Float64(Float64(-v) / t1); else tmp = Float64(v / u); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -6e+69) tmp = v / u; elseif (u <= 1.35e+221) tmp = -v / t1; else tmp = v / u; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -6e+69], N[(v / u), $MachinePrecision], If[LessEqual[u, 1.35e+221], N[((-v) / t1), $MachinePrecision], N[(v / u), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -6 \cdot 10^{+69}:\\
\;\;\;\;\frac{v}{u}\\
\mathbf{elif}\;u \leq 1.35 \cdot 10^{+221}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u}\\
\end{array}
\end{array}
if u < -5.99999999999999967e69 or 1.35e221 < u Initial program 86.2%
associate-/l*84.9%
neg-mul-184.9%
*-commutative84.9%
associate-*r/84.9%
associate-/l*84.8%
neg-mul-184.8%
associate-/r*92.4%
Simplified92.4%
associate-/l/84.8%
associate-*r/86.2%
distribute-rgt-neg-in86.2%
distribute-lft-neg-out86.2%
associate-/r*96.8%
Applied egg-rr97.4%
*-rgt-identity97.4%
associate-/r/90.1%
times-frac82.6%
/-rgt-identity82.6%
Simplified82.6%
Taylor expanded in t1 around inf 38.8%
Taylor expanded in t1 around 0 38.8%
if -5.99999999999999967e69 < u < 1.35e221Initial program 76.3%
associate-/l*70.8%
neg-mul-170.8%
*-commutative70.8%
associate-*r/70.4%
associate-/l*71.0%
neg-mul-171.0%
associate-/r*77.1%
Simplified77.1%
Taylor expanded in t1 around inf 67.0%
associate-*r/67.0%
neg-mul-167.0%
Simplified67.0%
Final simplification60.2%
(FPCore (u v t1) :precision binary64 (if (<= u -2.65e+70) (/ (- v) u) (if (<= u 3.3e+221) (/ (- v) t1) (/ v u))))
double code(double u, double v, double t1) {
double tmp;
if (u <= -2.65e+70) {
tmp = -v / u;
} else if (u <= 3.3e+221) {
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 (u <= (-2.65d+70)) then
tmp = -v / u
else if (u <= 3.3d+221) 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 (u <= -2.65e+70) {
tmp = -v / u;
} else if (u <= 3.3e+221) {
tmp = -v / t1;
} else {
tmp = v / u;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= -2.65e+70: tmp = -v / u elif u <= 3.3e+221: tmp = -v / t1 else: tmp = v / u return tmp
function code(u, v, t1) tmp = 0.0 if (u <= -2.65e+70) tmp = Float64(Float64(-v) / u); elseif (u <= 3.3e+221) tmp = Float64(Float64(-v) / t1); else tmp = Float64(v / u); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= -2.65e+70) tmp = -v / u; elseif (u <= 3.3e+221) tmp = -v / t1; else tmp = v / u; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, -2.65e+70], N[((-v) / u), $MachinePrecision], If[LessEqual[u, 3.3e+221], N[((-v) / t1), $MachinePrecision], N[(v / u), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -2.65 \cdot 10^{+70}:\\
\;\;\;\;\frac{-v}{u}\\
\mathbf{elif}\;u \leq 3.3 \cdot 10^{+221}:\\
\;\;\;\;\frac{-v}{t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u}\\
\end{array}
\end{array}
if u < -2.65e70Initial program 85.8%
*-commutative85.8%
times-frac88.6%
neg-mul-188.6%
associate-/l*88.6%
associate-*r/88.7%
associate-/l*88.7%
associate-/l/88.7%
neg-mul-188.7%
*-lft-identity88.7%
metadata-eval88.7%
times-frac88.7%
neg-mul-188.7%
remove-double-neg88.7%
neg-mul-188.7%
sub0-neg88.7%
associate--r+88.7%
neg-sub088.7%
div-sub88.7%
distribute-frac-neg88.7%
*-inverses88.7%
metadata-eval88.7%
Simplified88.7%
Taylor expanded in t1 around 0 85.0%
Taylor expanded in u around 0 34.7%
mul-1-neg34.7%
distribute-frac-neg34.7%
Simplified34.7%
if -2.65e70 < u < 3.29999999999999991e221Initial program 76.3%
associate-/l*70.8%
neg-mul-170.8%
*-commutative70.8%
associate-*r/70.4%
associate-/l*71.0%
neg-mul-171.0%
associate-/r*77.1%
Simplified77.1%
Taylor expanded in t1 around inf 67.0%
associate-*r/67.0%
neg-mul-167.0%
Simplified67.0%
if 3.29999999999999991e221 < u Initial program 86.9%
associate-/l*87.2%
neg-mul-187.2%
*-commutative87.2%
associate-*r/87.2%
associate-/l*87.2%
neg-mul-187.2%
associate-/r*91.5%
Simplified91.5%
associate-/l/87.2%
associate-*r/86.9%
distribute-rgt-neg-in86.9%
distribute-lft-neg-out86.9%
associate-/r*95.5%
Applied egg-rr100.0%
*-rgt-identity100.0%
associate-/r/99.9%
times-frac95.6%
/-rgt-identity95.6%
Simplified95.6%
Taylor expanded in t1 around inf 46.5%
Taylor expanded in t1 around 0 46.5%
Final simplification60.2%
(FPCore (u v t1) :precision binary64 (/ v (- (- u) t1)))
double code(double u, double v, double t1) {
return v / (-u - 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 - t1)
end function
public static double code(double u, double v, double t1) {
return v / (-u - t1);
}
def code(u, v, t1): return v / (-u - t1)
function code(u, v, t1) return Float64(v / Float64(Float64(-u) - t1)) end
function tmp = code(u, v, t1) tmp = v / (-u - t1); end
code[u_, v_, t1_] := N[(v / N[((-u) - t1), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{v}{\left(-u\right) - t1}
\end{array}
Initial program 78.7%
associate-/l*74.2%
neg-mul-174.2%
*-commutative74.2%
associate-*r/73.9%
associate-/l*74.4%
neg-mul-174.4%
associate-/r*80.8%
Simplified80.8%
associate-/l/74.4%
associate-*r/78.7%
distribute-rgt-neg-in78.7%
distribute-lft-neg-out78.7%
associate-/r*87.0%
Applied egg-rr56.3%
*-rgt-identity56.3%
associate-/r/56.5%
times-frac54.3%
/-rgt-identity54.3%
Simplified54.3%
Taylor expanded in t1 around inf 23.2%
associate-*l/23.2%
*-un-lft-identity23.2%
frac-2neg23.2%
add-sqr-sqrt11.9%
sqrt-unprod34.8%
sqr-neg34.8%
sqrt-unprod29.2%
add-sqr-sqrt60.8%
Applied egg-rr60.8%
neg-sub060.8%
+-commutative60.8%
associate--r+60.8%
neg-sub060.8%
Simplified60.8%
Final simplification60.8%
(FPCore (u v t1) :precision binary64 (/ v u))
double code(double u, double v, double t1) {
return v / 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 / u
end function
public static double code(double u, double v, double t1) {
return v / u;
}
def code(u, v, t1): return v / u
function code(u, v, t1) return Float64(v / u) end
function tmp = code(u, v, t1) tmp = v / u; end
code[u_, v_, t1_] := N[(v / u), $MachinePrecision]
\begin{array}{l}
\\
\frac{v}{u}
\end{array}
Initial program 78.7%
associate-/l*74.2%
neg-mul-174.2%
*-commutative74.2%
associate-*r/73.9%
associate-/l*74.4%
neg-mul-174.4%
associate-/r*80.8%
Simplified80.8%
associate-/l/74.4%
associate-*r/78.7%
distribute-rgt-neg-in78.7%
distribute-lft-neg-out78.7%
associate-/r*87.0%
Applied egg-rr56.3%
*-rgt-identity56.3%
associate-/r/56.5%
times-frac54.3%
/-rgt-identity54.3%
Simplified54.3%
Taylor expanded in t1 around inf 23.2%
Taylor expanded in t1 around 0 16.0%
Final simplification16.0%
herbie shell --seed 2023172
(FPCore (u v t1)
:name "Rosa's DopplerBench"
:precision binary64
(/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))