
(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 14 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 (- -1.0 (/ u t1))) (+ u t1)))
double code(double u, double v, double t1) {
return (v / (-1.0 - (u / t1))) / (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 / ((-1.0d0) - (u / t1))) / (u + t1)
end function
public static double code(double u, double v, double t1) {
return (v / (-1.0 - (u / t1))) / (u + t1);
}
def code(u, v, t1): return (v / (-1.0 - (u / t1))) / (u + t1)
function code(u, v, t1) return Float64(Float64(v / Float64(-1.0 - Float64(u / t1))) / Float64(u + t1)) end
function tmp = code(u, v, t1) tmp = (v / (-1.0 - (u / t1))) / (u + t1); end
code[u_, v_, t1_] := N[(N[(v / N[(-1.0 - N[(u / t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(u + t1), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{v}{-1 - \frac{u}{t1}}}{u + t1}
\end{array}
Initial program 74.4%
associate-/l*74.8%
distribute-lft-neg-out74.8%
distribute-rgt-neg-in74.8%
associate-/r*85.8%
distribute-neg-frac285.8%
Simplified85.8%
distribute-frac-neg285.8%
distribute-rgt-neg-out85.8%
associate-/r*74.8%
distribute-lft-neg-out74.8%
associate-/l*74.4%
times-frac97.4%
frac-2neg97.4%
associate-*r/97.8%
add-sqr-sqrt45.0%
sqrt-unprod43.7%
sqr-neg43.7%
sqrt-unprod22.0%
add-sqr-sqrt37.9%
add-sqr-sqrt14.8%
sqrt-unprod57.1%
sqr-neg57.1%
sqrt-prod50.9%
add-sqr-sqrt97.8%
Applied egg-rr97.8%
Taylor expanded in v around 0 85.7%
mul-1-neg85.7%
associate-*r/98.1%
*-commutative98.1%
associate-/r/97.8%
distribute-neg-frac97.8%
*-lft-identity97.8%
associate-*l/97.7%
+-commutative97.7%
distribute-rgt-in97.7%
rgt-mult-inverse97.7%
rgt-mult-inverse97.6%
fma-define97.6%
rgt-mult-inverse97.7%
Simplified97.7%
fma-undefine97.7%
un-div-inv97.8%
Applied egg-rr97.8%
Final simplification97.8%
(FPCore (u v t1) :precision binary64 (if (<= t1 -3.6e+134) (/ v (- (- t1) (* u 2.0))) (if (<= t1 9e+195) (* t1 (/ (/ v (+ u t1)) (- (- t1) u))) (/ v (- t1)))))
double code(double u, double v, double t1) {
double tmp;
if (t1 <= -3.6e+134) {
tmp = v / (-t1 - (u * 2.0));
} else if (t1 <= 9e+195) {
tmp = t1 * ((v / (u + t1)) / (-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 (t1 <= (-3.6d+134)) then
tmp = v / (-t1 - (u * 2.0d0))
else if (t1 <= 9d+195) then
tmp = t1 * ((v / (u + t1)) / (-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 (t1 <= -3.6e+134) {
tmp = v / (-t1 - (u * 2.0));
} else if (t1 <= 9e+195) {
tmp = t1 * ((v / (u + t1)) / (-t1 - u));
} else {
tmp = v / -t1;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if t1 <= -3.6e+134: tmp = v / (-t1 - (u * 2.0)) elif t1 <= 9e+195: tmp = t1 * ((v / (u + t1)) / (-t1 - u)) else: tmp = v / -t1 return tmp
function code(u, v, t1) tmp = 0.0 if (t1 <= -3.6e+134) tmp = Float64(v / Float64(Float64(-t1) - Float64(u * 2.0))); elseif (t1 <= 9e+195) tmp = Float64(t1 * Float64(Float64(v / Float64(u + t1)) / Float64(Float64(-t1) - u))); else tmp = Float64(v / Float64(-t1)); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (t1 <= -3.6e+134) tmp = v / (-t1 - (u * 2.0)); elseif (t1 <= 9e+195) tmp = t1 * ((v / (u + t1)) / (-t1 - u)); else tmp = v / -t1; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[t1, -3.6e+134], N[(v / N[((-t1) - N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t1, 9e+195], N[(t1 * N[(N[(v / N[(u + t1), $MachinePrecision]), $MachinePrecision] / N[((-t1) - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(v / (-t1)), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -3.6 \cdot 10^{+134}:\\
\;\;\;\;\frac{v}{\left(-t1\right) - u \cdot 2}\\
\mathbf{elif}\;t1 \leq 9 \cdot 10^{+195}:\\
\;\;\;\;t1 \cdot \frac{\frac{v}{u + t1}}{\left(-t1\right) - u}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{-t1}\\
\end{array}
\end{array}
if t1 < -3.59999999999999988e134Initial program 39.5%
associate-/l*38.2%
distribute-lft-neg-out38.2%
distribute-rgt-neg-in38.2%
associate-/r*72.1%
distribute-neg-frac272.1%
Simplified72.1%
associate-*r/99.9%
+-commutative99.9%
distribute-neg-in99.9%
sub-neg99.9%
associate-*l/100.0%
frac-2neg100.0%
clear-num100.0%
frac-times100.0%
*-un-lft-identity100.0%
+-commutative100.0%
distribute-neg-in100.0%
sub-neg100.0%
Applied egg-rr100.0%
Taylor expanded in u around 0 95.7%
*-commutative95.7%
Simplified95.7%
if -3.59999999999999988e134 < t1 < 9.00000000000000018e195Initial program 83.2%
associate-/l*83.7%
distribute-lft-neg-out83.7%
distribute-rgt-neg-in83.7%
associate-/r*90.9%
distribute-neg-frac290.9%
Simplified90.9%
if 9.00000000000000018e195 < t1 Initial program 53.6%
associate-/l*54.8%
distribute-lft-neg-out54.8%
distribute-rgt-neg-in54.8%
associate-/r*61.3%
distribute-neg-frac261.3%
Simplified61.3%
Taylor expanded in t1 around inf 100.0%
associate-*r/100.0%
neg-mul-1100.0%
Simplified100.0%
Final simplification92.4%
(FPCore (u v t1) :precision binary64 (if (or (<= t1 -1.1e-99) (not (<= t1 2e-97))) (/ v (- (- t1) (* u 2.0))) (/ v (* u (/ u (- t1))))))
double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -1.1e-99) || !(t1 <= 2e-97)) {
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.1d-99)) .or. (.not. (t1 <= 2d-97))) 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.1e-99) || !(t1 <= 2e-97)) {
tmp = v / (-t1 - (u * 2.0));
} else {
tmp = v / (u * (u / -t1));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (t1 <= -1.1e-99) or not (t1 <= 2e-97): 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.1e-99) || !(t1 <= 2e-97)) tmp = Float64(v / Float64(Float64(-t1) - Float64(u * 2.0))); else tmp = Float64(v / Float64(u * Float64(u / Float64(-t1)))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((t1 <= -1.1e-99) || ~((t1 <= 2e-97))) 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.1e-99], N[Not[LessEqual[t1, 2e-97]], $MachinePrecision]], N[(v / N[((-t1) - N[(u * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(v / N[(u * N[(u / (-t1)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -1.1 \cdot 10^{-99} \lor \neg \left(t1 \leq 2 \cdot 10^{-97}\right):\\
\;\;\;\;\frac{v}{\left(-t1\right) - u \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u \cdot \frac{u}{-t1}}\\
\end{array}
\end{array}
if t1 < -1.10000000000000002e-99 or 2.00000000000000007e-97 < t1 Initial program 69.2%
associate-/l*70.4%
distribute-lft-neg-out70.4%
distribute-rgt-neg-in70.4%
associate-/r*84.0%
distribute-neg-frac284.0%
Simplified84.0%
associate-*r/99.9%
+-commutative99.9%
distribute-neg-in99.9%
sub-neg99.9%
associate-*l/99.9%
frac-2neg99.9%
clear-num99.9%
frac-times96.1%
*-un-lft-identity96.1%
+-commutative96.1%
distribute-neg-in96.1%
sub-neg96.1%
Applied egg-rr96.1%
Taylor expanded in u around 0 80.8%
*-commutative80.8%
Simplified80.8%
if -1.10000000000000002e-99 < t1 < 2.00000000000000007e-97Initial program 85.4%
times-frac92.1%
distribute-frac-neg92.1%
distribute-neg-frac292.1%
+-commutative92.1%
distribute-neg-in92.1%
unsub-neg92.1%
Simplified92.1%
Taylor expanded in t1 around 0 85.4%
associate-*r/85.4%
mul-1-neg85.4%
Simplified85.4%
clear-num85.3%
frac-2neg85.3%
frac-times88.7%
*-un-lft-identity88.7%
add-sqr-sqrt45.5%
sqrt-unprod52.4%
sqr-neg52.4%
sqrt-unprod19.2%
add-sqr-sqrt48.2%
add-sqr-sqrt20.3%
sqrt-unprod51.6%
sqr-neg51.6%
sqrt-unprod55.2%
add-sqr-sqrt88.7%
distribute-neg-in88.7%
add-sqr-sqrt33.2%
sqrt-unprod91.1%
sqr-neg91.1%
sqrt-unprod56.6%
add-sqr-sqrt88.7%
sub-neg88.7%
Applied egg-rr88.7%
Taylor expanded in t1 around 0 91.2%
mul-1-neg91.2%
Simplified91.2%
Final simplification84.2%
(FPCore (u v t1) :precision binary64 (if (or (<= t1 -9.8e-104) (not (<= t1 5.2e-89))) (/ v (- u t1)) (/ v (* u (/ u (- t1))))))
double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -9.8e-104) || !(t1 <= 5.2e-89)) {
tmp = v / (u - t1);
} 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 <= (-9.8d-104)) .or. (.not. (t1 <= 5.2d-89))) then
tmp = v / (u - t1)
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 <= -9.8e-104) || !(t1 <= 5.2e-89)) {
tmp = v / (u - t1);
} else {
tmp = v / (u * (u / -t1));
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (t1 <= -9.8e-104) or not (t1 <= 5.2e-89): tmp = v / (u - t1) else: tmp = v / (u * (u / -t1)) return tmp
function code(u, v, t1) tmp = 0.0 if ((t1 <= -9.8e-104) || !(t1 <= 5.2e-89)) tmp = Float64(v / Float64(u - t1)); else tmp = Float64(v / Float64(u * Float64(u / Float64(-t1)))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((t1 <= -9.8e-104) || ~((t1 <= 5.2e-89))) tmp = v / (u - t1); else tmp = v / (u * (u / -t1)); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[t1, -9.8e-104], N[Not[LessEqual[t1, 5.2e-89]], $MachinePrecision]], N[(v / N[(u - t1), $MachinePrecision]), $MachinePrecision], N[(v / N[(u * N[(u / (-t1)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -9.8 \cdot 10^{-104} \lor \neg \left(t1 \leq 5.2 \cdot 10^{-89}\right):\\
\;\;\;\;\frac{v}{u - t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u \cdot \frac{u}{-t1}}\\
\end{array}
\end{array}
if t1 < -9.8000000000000006e-104 or 5.1999999999999997e-89 < t1 Initial program 68.8%
associate-/l*70.1%
distribute-lft-neg-out70.1%
distribute-rgt-neg-in70.1%
associate-/r*83.8%
distribute-neg-frac283.8%
Simplified83.8%
distribute-frac-neg283.8%
distribute-rgt-neg-out83.8%
associate-/r*70.1%
distribute-lft-neg-out70.1%
associate-/l*68.8%
times-frac99.9%
frac-2neg99.9%
associate-*r/99.9%
add-sqr-sqrt50.6%
sqrt-unprod41.7%
sqr-neg41.7%
sqrt-unprod20.0%
add-sqr-sqrt34.5%
add-sqr-sqrt13.0%
sqrt-unprod52.8%
sqr-neg52.8%
sqrt-prod50.7%
add-sqr-sqrt99.9%
Applied egg-rr99.9%
Taylor expanded in t1 around inf 80.8%
mul-1-neg80.8%
Simplified80.8%
distribute-frac-neg80.8%
neg-sub080.8%
frac-2neg80.8%
add-sqr-sqrt40.7%
sqrt-unprod47.3%
sqr-neg47.3%
sqrt-unprod14.6%
add-sqr-sqrt28.9%
distribute-neg-in28.9%
add-sqr-sqrt12.2%
sqrt-unprod44.5%
sqr-neg44.5%
sqrt-unprod38.9%
add-sqr-sqrt80.9%
sub-neg80.9%
Applied egg-rr80.9%
neg-sub080.9%
distribute-neg-frac80.9%
Simplified80.9%
frac-2neg80.9%
div-inv80.7%
remove-double-neg80.7%
sub-neg80.7%
distribute-neg-in80.7%
add-sqr-sqrt40.1%
sqrt-unprod82.6%
sqr-neg82.6%
sqrt-unprod40.5%
add-sqr-sqrt80.6%
distribute-neg-in80.6%
+-commutative80.6%
distribute-neg-in80.6%
add-sqr-sqrt40.1%
sqrt-unprod82.7%
sqr-neg82.7%
sqrt-unprod40.6%
add-sqr-sqrt80.7%
Applied egg-rr80.7%
sub-neg80.7%
associate-*r/80.9%
*-rgt-identity80.9%
Simplified80.9%
if -9.8000000000000006e-104 < t1 < 5.1999999999999997e-89Initial program 85.7%
times-frac92.3%
distribute-frac-neg92.3%
distribute-neg-frac292.3%
+-commutative92.3%
distribute-neg-in92.3%
unsub-neg92.3%
Simplified92.3%
Taylor expanded in t1 around 0 84.7%
associate-*r/84.7%
mul-1-neg84.7%
Simplified84.7%
clear-num84.6%
frac-2neg84.6%
frac-times87.8%
*-un-lft-identity87.8%
add-sqr-sqrt45.6%
sqrt-unprod52.3%
sqr-neg52.3%
sqrt-unprod18.7%
add-sqr-sqrt47.2%
add-sqr-sqrt19.9%
sqrt-unprod51.6%
sqr-neg51.6%
sqrt-unprod55.1%
add-sqr-sqrt87.8%
distribute-neg-in87.8%
add-sqr-sqrt32.5%
sqrt-unprod90.1%
sqr-neg90.1%
sqrt-unprod56.5%
add-sqr-sqrt87.8%
sub-neg87.8%
Applied egg-rr87.8%
Taylor expanded in t1 around 0 90.3%
mul-1-neg90.3%
Simplified90.3%
Final simplification84.0%
(FPCore (u v t1) :precision binary64 (if (or (<= t1 -9.5e-60) (not (<= t1 2.9e-19))) (/ v (- u t1)) (* (/ (- t1) u) (/ v u))))
double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -9.5e-60) || !(t1 <= 2.9e-19)) {
tmp = v / (u - t1);
} else {
tmp = (-t1 / u) * (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 <= (-9.5d-60)) .or. (.not. (t1 <= 2.9d-19))) then
tmp = v / (u - t1)
else
tmp = (-t1 / u) * (v / u)
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -9.5e-60) || !(t1 <= 2.9e-19)) {
tmp = v / (u - t1);
} else {
tmp = (-t1 / u) * (v / u);
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (t1 <= -9.5e-60) or not (t1 <= 2.9e-19): tmp = v / (u - t1) else: tmp = (-t1 / u) * (v / u) return tmp
function code(u, v, t1) tmp = 0.0 if ((t1 <= -9.5e-60) || !(t1 <= 2.9e-19)) tmp = Float64(v / Float64(u - t1)); else tmp = Float64(Float64(Float64(-t1) / u) * Float64(v / u)); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((t1 <= -9.5e-60) || ~((t1 <= 2.9e-19))) tmp = v / (u - t1); else tmp = (-t1 / u) * (v / u); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[t1, -9.5e-60], N[Not[LessEqual[t1, 2.9e-19]], $MachinePrecision]], N[(v / N[(u - t1), $MachinePrecision]), $MachinePrecision], N[(N[((-t1) / u), $MachinePrecision] * N[(v / u), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -9.5 \cdot 10^{-60} \lor \neg \left(t1 \leq 2.9 \cdot 10^{-19}\right):\\
\;\;\;\;\frac{v}{u - t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{-t1}{u} \cdot \frac{v}{u}\\
\end{array}
\end{array}
if t1 < -9.49999999999999958e-60 or 2.9e-19 < t1 Initial program 67.4%
associate-/l*68.8%
distribute-lft-neg-out68.8%
distribute-rgt-neg-in68.8%
associate-/r*83.0%
distribute-neg-frac283.0%
Simplified83.0%
distribute-frac-neg283.0%
distribute-rgt-neg-out83.0%
associate-/r*68.8%
distribute-lft-neg-out68.8%
associate-/l*67.4%
times-frac99.9%
frac-2neg99.9%
associate-*r/99.9%
add-sqr-sqrt52.3%
sqrt-unprod40.1%
sqr-neg40.1%
sqrt-unprod20.4%
add-sqr-sqrt35.3%
add-sqr-sqrt13.2%
sqrt-unprod51.4%
sqr-neg51.4%
sqrt-prod49.1%
add-sqr-sqrt99.9%
Applied egg-rr99.9%
Taylor expanded in t1 around inf 83.6%
mul-1-neg83.6%
Simplified83.6%
distribute-frac-neg83.6%
neg-sub083.6%
frac-2neg83.6%
add-sqr-sqrt41.7%
sqrt-unprod49.9%
sqr-neg49.9%
sqrt-unprod15.9%
add-sqr-sqrt30.5%
distribute-neg-in30.5%
add-sqr-sqrt13.2%
sqrt-unprod44.7%
sqr-neg44.7%
sqrt-unprod39.0%
add-sqr-sqrt83.7%
sub-neg83.7%
Applied egg-rr83.7%
neg-sub083.7%
distribute-neg-frac83.7%
Simplified83.7%
frac-2neg83.7%
div-inv83.5%
remove-double-neg83.5%
sub-neg83.5%
distribute-neg-in83.5%
add-sqr-sqrt41.0%
sqrt-unprod84.1%
sqr-neg84.1%
sqrt-unprod42.4%
add-sqr-sqrt83.4%
distribute-neg-in83.4%
+-commutative83.4%
distribute-neg-in83.4%
add-sqr-sqrt41.0%
sqrt-unprod84.3%
sqr-neg84.3%
sqrt-unprod42.5%
add-sqr-sqrt83.5%
Applied egg-rr83.5%
sub-neg83.5%
associate-*r/83.7%
*-rgt-identity83.7%
Simplified83.7%
if -9.49999999999999958e-60 < t1 < 2.9e-19Initial program 84.7%
times-frac93.7%
distribute-frac-neg93.7%
distribute-neg-frac293.7%
+-commutative93.7%
distribute-neg-in93.7%
unsub-neg93.7%
Simplified93.7%
Taylor expanded in t1 around 0 79.9%
associate-*r/79.9%
mul-1-neg79.9%
Simplified79.9%
Taylor expanded in t1 around 0 82.1%
Final simplification83.1%
(FPCore (u v t1) :precision binary64 (if (or (<= t1 -1.12e-55) (not (<= t1 1.35e-19))) (/ v (- u t1)) (* t1 (/ (/ v u) (- u)))))
double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -1.12e-55) || !(t1 <= 1.35e-19)) {
tmp = v / (u - t1);
} else {
tmp = t1 * ((v / u) / -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 <= (-1.12d-55)) .or. (.not. (t1 <= 1.35d-19))) then
tmp = v / (u - t1)
else
tmp = t1 * ((v / u) / -u)
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -1.12e-55) || !(t1 <= 1.35e-19)) {
tmp = v / (u - t1);
} else {
tmp = t1 * ((v / u) / -u);
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (t1 <= -1.12e-55) or not (t1 <= 1.35e-19): tmp = v / (u - t1) else: tmp = t1 * ((v / u) / -u) return tmp
function code(u, v, t1) tmp = 0.0 if ((t1 <= -1.12e-55) || !(t1 <= 1.35e-19)) tmp = Float64(v / Float64(u - t1)); else tmp = Float64(t1 * Float64(Float64(v / u) / Float64(-u))); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((t1 <= -1.12e-55) || ~((t1 <= 1.35e-19))) tmp = v / (u - t1); else tmp = t1 * ((v / u) / -u); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.12e-55], N[Not[LessEqual[t1, 1.35e-19]], $MachinePrecision]], N[(v / N[(u - t1), $MachinePrecision]), $MachinePrecision], N[(t1 * N[(N[(v / u), $MachinePrecision] / (-u)), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -1.12 \cdot 10^{-55} \lor \neg \left(t1 \leq 1.35 \cdot 10^{-19}\right):\\
\;\;\;\;\frac{v}{u - t1}\\
\mathbf{else}:\\
\;\;\;\;t1 \cdot \frac{\frac{v}{u}}{-u}\\
\end{array}
\end{array}
if t1 < -1.11999999999999997e-55 or 1.35e-19 < t1 Initial program 67.4%
associate-/l*68.8%
distribute-lft-neg-out68.8%
distribute-rgt-neg-in68.8%
associate-/r*83.0%
distribute-neg-frac283.0%
Simplified83.0%
distribute-frac-neg283.0%
distribute-rgt-neg-out83.0%
associate-/r*68.8%
distribute-lft-neg-out68.8%
associate-/l*67.4%
times-frac99.9%
frac-2neg99.9%
associate-*r/99.9%
add-sqr-sqrt52.3%
sqrt-unprod40.1%
sqr-neg40.1%
sqrt-unprod20.4%
add-sqr-sqrt35.3%
add-sqr-sqrt13.2%
sqrt-unprod51.4%
sqr-neg51.4%
sqrt-prod49.1%
add-sqr-sqrt99.9%
Applied egg-rr99.9%
Taylor expanded in t1 around inf 83.6%
mul-1-neg83.6%
Simplified83.6%
distribute-frac-neg83.6%
neg-sub083.6%
frac-2neg83.6%
add-sqr-sqrt41.7%
sqrt-unprod49.9%
sqr-neg49.9%
sqrt-unprod15.9%
add-sqr-sqrt30.5%
distribute-neg-in30.5%
add-sqr-sqrt13.2%
sqrt-unprod44.7%
sqr-neg44.7%
sqrt-unprod39.0%
add-sqr-sqrt83.7%
sub-neg83.7%
Applied egg-rr83.7%
neg-sub083.7%
distribute-neg-frac83.7%
Simplified83.7%
frac-2neg83.7%
div-inv83.5%
remove-double-neg83.5%
sub-neg83.5%
distribute-neg-in83.5%
add-sqr-sqrt41.0%
sqrt-unprod84.1%
sqr-neg84.1%
sqrt-unprod42.4%
add-sqr-sqrt83.4%
distribute-neg-in83.4%
+-commutative83.4%
distribute-neg-in83.4%
add-sqr-sqrt41.0%
sqrt-unprod84.3%
sqr-neg84.3%
sqrt-unprod42.5%
add-sqr-sqrt83.5%
Applied egg-rr83.5%
sub-neg83.5%
associate-*r/83.7%
*-rgt-identity83.7%
Simplified83.7%
if -1.11999999999999997e-55 < t1 < 1.35e-19Initial program 84.7%
associate-/l*83.5%
distribute-lft-neg-out83.5%
distribute-rgt-neg-in83.5%
associate-/r*89.9%
distribute-neg-frac289.9%
Simplified89.9%
Taylor expanded in t1 around 0 78.8%
mul-1-neg78.8%
Simplified78.8%
Taylor expanded in t1 around 0 81.0%
Final simplification82.6%
(FPCore (u v t1) :precision binary64 (if (or (<= u -1.65e+75) (not (<= u 4.2e+66))) (/ t1 (* u (/ u v))) (/ v (- t1))))
double code(double u, double v, double t1) {
double tmp;
if ((u <= -1.65e+75) || !(u <= 4.2e+66)) {
tmp = t1 / (u * (u / v));
} 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 <= (-1.65d+75)) .or. (.not. (u <= 4.2d+66))) then
tmp = t1 / (u * (u / v))
else
tmp = v / -t1
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if ((u <= -1.65e+75) || !(u <= 4.2e+66)) {
tmp = t1 / (u * (u / v));
} else {
tmp = v / -t1;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (u <= -1.65e+75) or not (u <= 4.2e+66): tmp = t1 / (u * (u / v)) else: tmp = v / -t1 return tmp
function code(u, v, t1) tmp = 0.0 if ((u <= -1.65e+75) || !(u <= 4.2e+66)) tmp = Float64(t1 / Float64(u * Float64(u / v))); else tmp = Float64(v / Float64(-t1)); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if ((u <= -1.65e+75) || ~((u <= 4.2e+66))) tmp = t1 / (u * (u / v)); else tmp = v / -t1; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[u, -1.65e+75], N[Not[LessEqual[u, 4.2e+66]], $MachinePrecision]], N[(t1 / N[(u * N[(u / v), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(v / (-t1)), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq -1.65 \cdot 10^{+75} \lor \neg \left(u \leq 4.2 \cdot 10^{+66}\right):\\
\;\;\;\;\frac{t1}{u \cdot \frac{u}{v}}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{-t1}\\
\end{array}
\end{array}
if u < -1.64999999999999999e75 or 4.20000000000000011e66 < u Initial program 76.5%
associate-/l*76.6%
distribute-lft-neg-out76.6%
distribute-rgt-neg-in76.6%
associate-/r*91.6%
distribute-neg-frac291.6%
Simplified91.6%
Taylor expanded in t1 around 0 84.8%
mul-1-neg84.8%
Simplified84.8%
Taylor expanded in t1 around 0 83.8%
clear-num83.0%
un-div-inv83.0%
div-inv83.0%
clear-num83.1%
add-sqr-sqrt32.4%
sqrt-unprod70.0%
sqr-neg70.0%
sqrt-unprod41.0%
add-sqr-sqrt64.8%
Applied egg-rr64.8%
if -1.64999999999999999e75 < u < 4.20000000000000011e66Initial program 73.1%
associate-/l*73.6%
distribute-lft-neg-out73.6%
distribute-rgt-neg-in73.6%
associate-/r*82.0%
distribute-neg-frac282.0%
Simplified82.0%
Taylor expanded in t1 around inf 74.4%
associate-*r/74.4%
neg-mul-174.4%
Simplified74.4%
Final simplification70.6%
(FPCore (u v t1) :precision binary64 (if (or (<= t1 -1.75e+132) (not (<= t1 2.3e+79))) (/ v t1) (/ v u)))
double code(double u, double v, double t1) {
double tmp;
if ((t1 <= -1.75e+132) || !(t1 <= 2.3e+79)) {
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 <= (-1.75d+132)) .or. (.not. (t1 <= 2.3d+79))) 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 <= -1.75e+132) || !(t1 <= 2.3e+79)) {
tmp = v / t1;
} else {
tmp = v / u;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if (t1 <= -1.75e+132) or not (t1 <= 2.3e+79): tmp = v / t1 else: tmp = v / u return tmp
function code(u, v, t1) tmp = 0.0 if ((t1 <= -1.75e+132) || !(t1 <= 2.3e+79)) 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 <= -1.75e+132) || ~((t1 <= 2.3e+79))) tmp = v / t1; else tmp = v / u; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[Or[LessEqual[t1, -1.75e+132], N[Not[LessEqual[t1, 2.3e+79]], $MachinePrecision]], N[(v / t1), $MachinePrecision], N[(v / u), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t1 \leq -1.75 \cdot 10^{+132} \lor \neg \left(t1 \leq 2.3 \cdot 10^{+79}\right):\\
\;\;\;\;\frac{v}{t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u}\\
\end{array}
\end{array}
if t1 < -1.7500000000000001e132 or 2.3e79 < t1 Initial program 51.5%
associate-/l*50.2%
distribute-lft-neg-out50.2%
distribute-rgt-neg-in50.2%
associate-/r*72.5%
distribute-neg-frac272.5%
Simplified72.5%
Taylor expanded in t1 around inf 88.8%
associate-*r/88.8%
neg-mul-188.8%
Simplified88.8%
neg-sub088.8%
sub-neg88.8%
add-sqr-sqrt42.4%
sqrt-unprod56.2%
sqr-neg56.2%
sqrt-unprod20.9%
add-sqr-sqrt39.0%
Applied egg-rr39.0%
+-lft-identity39.0%
Simplified39.0%
if -1.7500000000000001e132 < t1 < 2.3e79Initial program 85.4%
associate-/l*86.6%
distribute-lft-neg-out86.6%
distribute-rgt-neg-in86.6%
associate-/r*92.2%
distribute-neg-frac292.2%
Simplified92.2%
distribute-frac-neg292.2%
distribute-rgt-neg-out92.2%
associate-/r*86.6%
distribute-lft-neg-out86.6%
associate-/l*85.4%
times-frac96.2%
frac-2neg96.2%
associate-*r/96.7%
add-sqr-sqrt45.4%
sqrt-unprod58.7%
sqr-neg58.7%
sqrt-unprod19.2%
add-sqr-sqrt35.2%
add-sqr-sqrt14.5%
sqrt-unprod59.8%
sqr-neg59.8%
sqrt-prod50.0%
add-sqr-sqrt96.7%
Applied egg-rr96.7%
Taylor expanded in t1 around inf 47.2%
mul-1-neg47.2%
Simplified47.2%
distribute-frac-neg47.2%
neg-sub047.2%
frac-2neg47.2%
add-sqr-sqrt24.9%
sqrt-unprod30.3%
sqr-neg30.3%
sqrt-unprod7.4%
add-sqr-sqrt16.2%
distribute-neg-in16.2%
add-sqr-sqrt7.7%
sqrt-unprod29.9%
sqr-neg29.9%
sqrt-unprod22.1%
add-sqr-sqrt48.4%
sub-neg48.4%
Applied egg-rr48.4%
neg-sub048.4%
distribute-neg-frac48.4%
Simplified48.4%
Taylor expanded in t1 around 0 17.3%
Final simplification24.3%
(FPCore (u v t1) :precision binary64 (/ (* v (/ (- t1) (+ u t1))) (+ u t1)))
double code(double u, double v, double t1) {
return (v * (-t1 / (u + t1))) / (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 * (-t1 / (u + t1))) / (u + t1)
end function
public static double code(double u, double v, double t1) {
return (v * (-t1 / (u + t1))) / (u + t1);
}
def code(u, v, t1): return (v * (-t1 / (u + t1))) / (u + t1)
function code(u, v, t1) return Float64(Float64(v * Float64(Float64(-t1) / Float64(u + t1))) / Float64(u + t1)) end
function tmp = code(u, v, t1) tmp = (v * (-t1 / (u + t1))) / (u + t1); end
code[u_, v_, t1_] := N[(N[(v * N[((-t1) / N[(u + t1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(u + t1), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{v \cdot \frac{-t1}{u + t1}}{u + t1}
\end{array}
Initial program 74.4%
associate-/l*74.8%
distribute-lft-neg-out74.8%
distribute-rgt-neg-in74.8%
associate-/r*85.8%
distribute-neg-frac285.8%
Simplified85.8%
distribute-frac-neg285.8%
distribute-rgt-neg-out85.8%
associate-/r*74.8%
distribute-lft-neg-out74.8%
associate-/l*74.4%
times-frac97.4%
frac-2neg97.4%
associate-*r/97.8%
add-sqr-sqrt45.0%
sqrt-unprod43.7%
sqr-neg43.7%
sqrt-unprod22.0%
add-sqr-sqrt37.9%
add-sqr-sqrt14.8%
sqrt-unprod57.1%
sqr-neg57.1%
sqrt-prod50.9%
add-sqr-sqrt97.8%
Applied egg-rr97.8%
Final simplification97.8%
(FPCore (u v t1) :precision binary64 (* (/ t1 (+ u t1)) (/ v (- (- t1) u))))
double code(double u, double v, double t1) {
return (t1 / (u + t1)) * (v / (-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 / (u + t1)) * (v / (-t1 - u))
end function
public static double code(double u, double v, double t1) {
return (t1 / (u + t1)) * (v / (-t1 - u));
}
def code(u, v, t1): return (t1 / (u + t1)) * (v / (-t1 - u))
function code(u, v, t1) return Float64(Float64(t1 / Float64(u + t1)) * Float64(v / Float64(Float64(-t1) - u))) end
function tmp = code(u, v, t1) tmp = (t1 / (u + t1)) * (v / (-t1 - u)); end
code[u_, v_, t1_] := N[(N[(t1 / N[(u + t1), $MachinePrecision]), $MachinePrecision] * N[(v / N[((-t1) - u), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{t1}{u + t1} \cdot \frac{v}{\left(-t1\right) - u}
\end{array}
Initial program 74.4%
times-frac97.4%
distribute-frac-neg97.4%
distribute-neg-frac297.4%
+-commutative97.4%
distribute-neg-in97.4%
unsub-neg97.4%
Simplified97.4%
Final simplification97.4%
(FPCore (u v t1) :precision binary64 (if (<= u 3e+145) (/ v (- t1)) (/ 1.0 (/ u v))))
double code(double u, double v, double t1) {
double tmp;
if (u <= 3e+145) {
tmp = v / -t1;
} else {
tmp = 1.0 / (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 <= 3d+145) then
tmp = v / -t1
else
tmp = 1.0d0 / (u / v)
end if
code = tmp
end function
public static double code(double u, double v, double t1) {
double tmp;
if (u <= 3e+145) {
tmp = v / -t1;
} else {
tmp = 1.0 / (u / v);
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= 3e+145: tmp = v / -t1 else: tmp = 1.0 / (u / v) return tmp
function code(u, v, t1) tmp = 0.0 if (u <= 3e+145) tmp = Float64(v / Float64(-t1)); else tmp = Float64(1.0 / Float64(u / v)); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= 3e+145) tmp = v / -t1; else tmp = 1.0 / (u / v); end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, 3e+145], N[(v / (-t1)), $MachinePrecision], N[(1.0 / N[(u / v), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq 3 \cdot 10^{+145}:\\
\;\;\;\;\frac{v}{-t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{u}{v}}\\
\end{array}
\end{array}
if u < 3.0000000000000002e145Initial program 73.6%
associate-/l*74.0%
distribute-lft-neg-out74.0%
distribute-rgt-neg-in74.0%
associate-/r*84.3%
distribute-neg-frac284.3%
Simplified84.3%
Taylor expanded in t1 around inf 60.9%
associate-*r/60.9%
neg-mul-160.9%
Simplified60.9%
if 3.0000000000000002e145 < u Initial program 79.5%
associate-/l*79.6%
distribute-lft-neg-out79.6%
distribute-rgt-neg-in79.6%
associate-/r*94.5%
distribute-neg-frac294.5%
Simplified94.5%
Taylor expanded in t1 around 0 94.5%
mul-1-neg94.5%
Simplified94.5%
Taylor expanded in t1 around inf 45.3%
associate-*r/45.3%
mul-1-neg45.3%
Simplified45.3%
add-sqr-sqrt26.7%
sqrt-unprod45.0%
sqr-neg45.0%
sqrt-unprod18.7%
add-sqr-sqrt45.4%
clear-num46.4%
inv-pow46.4%
Applied egg-rr46.4%
unpow-146.4%
Simplified46.4%
Final simplification58.8%
(FPCore (u v t1) :precision binary64 (if (<= u 5.5e+144) (/ v (- t1)) (/ v u)))
double code(double u, double v, double t1) {
double tmp;
if (u <= 5.5e+144) {
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 <= 5.5d+144) 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 <= 5.5e+144) {
tmp = v / -t1;
} else {
tmp = v / u;
}
return tmp;
}
def code(u, v, t1): tmp = 0 if u <= 5.5e+144: tmp = v / -t1 else: tmp = v / u return tmp
function code(u, v, t1) tmp = 0.0 if (u <= 5.5e+144) tmp = Float64(v / Float64(-t1)); else tmp = Float64(v / u); end return tmp end
function tmp_2 = code(u, v, t1) tmp = 0.0; if (u <= 5.5e+144) tmp = v / -t1; else tmp = v / u; end tmp_2 = tmp; end
code[u_, v_, t1_] := If[LessEqual[u, 5.5e+144], N[(v / (-t1)), $MachinePrecision], N[(v / u), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;u \leq 5.5 \cdot 10^{+144}:\\
\;\;\;\;\frac{v}{-t1}\\
\mathbf{else}:\\
\;\;\;\;\frac{v}{u}\\
\end{array}
\end{array}
if u < 5.50000000000000022e144Initial program 73.6%
associate-/l*74.0%
distribute-lft-neg-out74.0%
distribute-rgt-neg-in74.0%
associate-/r*84.3%
distribute-neg-frac284.3%
Simplified84.3%
Taylor expanded in t1 around inf 60.9%
associate-*r/60.9%
neg-mul-160.9%
Simplified60.9%
if 5.50000000000000022e144 < u Initial program 79.5%
associate-/l*79.6%
distribute-lft-neg-out79.6%
distribute-rgt-neg-in79.6%
associate-/r*94.5%
distribute-neg-frac294.5%
Simplified94.5%
distribute-frac-neg294.5%
distribute-rgt-neg-out94.5%
associate-/r*79.6%
distribute-lft-neg-out79.6%
associate-/l*79.5%
times-frac97.4%
frac-2neg97.4%
associate-*r/97.4%
add-sqr-sqrt38.0%
sqrt-unprod68.6%
sqr-neg68.6%
sqrt-unprod46.6%
add-sqr-sqrt79.3%
add-sqr-sqrt0.0%
sqrt-unprod79.6%
sqr-neg79.6%
sqrt-prod97.3%
add-sqr-sqrt97.4%
Applied egg-rr97.4%
Taylor expanded in t1 around inf 45.3%
mul-1-neg45.3%
Simplified45.3%
distribute-frac-neg45.3%
neg-sub045.3%
frac-2neg45.3%
add-sqr-sqrt26.7%
sqrt-unprod45.0%
sqr-neg45.0%
sqrt-unprod18.7%
add-sqr-sqrt45.4%
distribute-neg-in45.4%
add-sqr-sqrt17.0%
sqrt-unprod47.7%
sqr-neg47.7%
sqrt-unprod28.4%
add-sqr-sqrt45.4%
sub-neg45.4%
Applied egg-rr45.4%
neg-sub045.4%
distribute-neg-frac45.4%
Simplified45.4%
Taylor expanded in t1 around 0 45.4%
Final simplification58.6%
(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(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}{u - t1}
\end{array}
Initial program 74.4%
associate-/l*74.8%
distribute-lft-neg-out74.8%
distribute-rgt-neg-in74.8%
associate-/r*85.8%
distribute-neg-frac285.8%
Simplified85.8%
distribute-frac-neg285.8%
distribute-rgt-neg-out85.8%
associate-/r*74.8%
distribute-lft-neg-out74.8%
associate-/l*74.4%
times-frac97.4%
frac-2neg97.4%
associate-*r/97.8%
add-sqr-sqrt45.0%
sqrt-unprod43.7%
sqr-neg43.7%
sqrt-unprod22.0%
add-sqr-sqrt37.9%
add-sqr-sqrt14.8%
sqrt-unprod57.1%
sqr-neg57.1%
sqrt-prod50.9%
add-sqr-sqrt97.8%
Applied egg-rr97.8%
Taylor expanded in t1 around inf 61.4%
mul-1-neg61.4%
Simplified61.4%
distribute-frac-neg61.4%
neg-sub061.4%
frac-2neg61.4%
add-sqr-sqrt30.5%
sqrt-unprod39.4%
sqr-neg39.4%
sqrt-unprod12.5%
add-sqr-sqrt24.4%
distribute-neg-in24.4%
add-sqr-sqrt10.2%
sqrt-unprod36.4%
sqr-neg36.4%
sqrt-unprod30.6%
add-sqr-sqrt62.2%
sub-neg62.2%
Applied egg-rr62.2%
neg-sub062.2%
distribute-neg-frac62.2%
Simplified62.2%
frac-2neg62.2%
div-inv62.1%
remove-double-neg62.1%
sub-neg62.1%
distribute-neg-in62.1%
add-sqr-sqrt30.9%
sqrt-unprod67.3%
sqr-neg67.3%
sqrt-unprod30.9%
add-sqr-sqrt61.2%
distribute-neg-in61.2%
+-commutative61.2%
distribute-neg-in61.2%
add-sqr-sqrt30.4%
sqrt-unprod67.2%
sqr-neg67.2%
sqrt-unprod31.2%
add-sqr-sqrt62.1%
Applied egg-rr62.1%
sub-neg62.1%
associate-*r/62.2%
*-rgt-identity62.2%
Simplified62.2%
(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 74.4%
associate-/l*74.8%
distribute-lft-neg-out74.8%
distribute-rgt-neg-in74.8%
associate-/r*85.8%
distribute-neg-frac285.8%
Simplified85.8%
Taylor expanded in t1 around inf 54.0%
associate-*r/54.0%
neg-mul-154.0%
Simplified54.0%
neg-sub054.0%
sub-neg54.0%
add-sqr-sqrt26.7%
sqrt-unprod35.4%
sqr-neg35.4%
sqrt-unprod7.8%
add-sqr-sqrt14.7%
Applied egg-rr14.7%
+-lft-identity14.7%
Simplified14.7%
herbie shell --seed 2024112
(FPCore (u v t1)
:name "Rosa's DopplerBench"
:precision binary64
(/ (* (- t1) v) (* (+ t1 u) (+ t1 u))))