
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + (t / ((z * 3.0d0) * y))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(Float64(z * 3.0) * y))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y)); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + (t / ((z * 3.0d0) * y))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(Float64(z * 3.0) * y))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / ((z * 3.0) * y)); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(N[(z * 3.0), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{\left(z \cdot 3\right) \cdot y}
\end{array}
(FPCore (x y z t) :precision binary64 (if (<= (* z 3.0) -1e-57) (+ (- x (/ y (* z 3.0))) (/ t (* y (* z 3.0)))) (+ x (* (/ -0.3333333333333333 z) (- y (/ t y))))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z * 3.0) <= -1e-57) {
tmp = (x - (y / (z * 3.0))) + (t / (y * (z * 3.0)));
} else {
tmp = x + ((-0.3333333333333333 / z) * (y - (t / y)));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((z * 3.0d0) <= (-1d-57)) then
tmp = (x - (y / (z * 3.0d0))) + (t / (y * (z * 3.0d0)))
else
tmp = x + (((-0.3333333333333333d0) / z) * (y - (t / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z * 3.0) <= -1e-57) {
tmp = (x - (y / (z * 3.0))) + (t / (y * (z * 3.0)));
} else {
tmp = x + ((-0.3333333333333333 / z) * (y - (t / y)));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z * 3.0) <= -1e-57: tmp = (x - (y / (z * 3.0))) + (t / (y * (z * 3.0))) else: tmp = x + ((-0.3333333333333333 / z) * (y - (t / y))) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(z * 3.0) <= -1e-57) tmp = Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(y * Float64(z * 3.0)))); else tmp = Float64(x + Float64(Float64(-0.3333333333333333 / z) * Float64(y - Float64(t / y)))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z * 3.0) <= -1e-57) tmp = (x - (y / (z * 3.0))) + (t / (y * (z * 3.0))); else tmp = x + ((-0.3333333333333333 / z) * (y - (t / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(z * 3.0), $MachinePrecision], -1e-57], N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(y * N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(-0.3333333333333333 / z), $MachinePrecision] * N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -1 \cdot 10^{-57}:\\
\;\;\;\;\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{y \cdot \left(z \cdot 3\right)}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{-0.3333333333333333}{z} \cdot \left(y - \frac{t}{y}\right)\\
\end{array}
\end{array}
if (*.f64 z #s(literal 3 binary64)) < -9.99999999999999955e-58Initial program 99.6%
if -9.99999999999999955e-58 < (*.f64 z #s(literal 3 binary64)) Initial program 94.0%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6498.2%
Simplified98.2%
Final simplification98.6%
(FPCore (x y z t)
:precision binary64
(if (<= y -2.95e+75)
(/ -0.3333333333333333 (/ z y))
(if (<= y -1.45e-93)
x
(if (<= y 3.3e+38)
(* (/ t z) (/ 0.3333333333333333 y))
(- 0.0 (/ y (* z 3.0)))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -2.95e+75) {
tmp = -0.3333333333333333 / (z / y);
} else if (y <= -1.45e-93) {
tmp = x;
} else if (y <= 3.3e+38) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = 0.0 - (y / (z * 3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= (-2.95d+75)) then
tmp = (-0.3333333333333333d0) / (z / y)
else if (y <= (-1.45d-93)) then
tmp = x
else if (y <= 3.3d+38) then
tmp = (t / z) * (0.3333333333333333d0 / y)
else
tmp = 0.0d0 - (y / (z * 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -2.95e+75) {
tmp = -0.3333333333333333 / (z / y);
} else if (y <= -1.45e-93) {
tmp = x;
} else if (y <= 3.3e+38) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = 0.0 - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -2.95e+75: tmp = -0.3333333333333333 / (z / y) elif y <= -1.45e-93: tmp = x elif y <= 3.3e+38: tmp = (t / z) * (0.3333333333333333 / y) else: tmp = 0.0 - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -2.95e+75) tmp = Float64(-0.3333333333333333 / Float64(z / y)); elseif (y <= -1.45e-93) tmp = x; elseif (y <= 3.3e+38) tmp = Float64(Float64(t / z) * Float64(0.3333333333333333 / y)); else tmp = Float64(0.0 - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -2.95e+75) tmp = -0.3333333333333333 / (z / y); elseif (y <= -1.45e-93) tmp = x; elseif (y <= 3.3e+38) tmp = (t / z) * (0.3333333333333333 / y); else tmp = 0.0 - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -2.95e+75], N[(-0.3333333333333333 / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.45e-93], x, If[LessEqual[y, 3.3e+38], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.95 \cdot 10^{+75}:\\
\;\;\;\;\frac{-0.3333333333333333}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq -1.45 \cdot 10^{-93}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+38}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -2.94999999999999991e75Initial program 99.7%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval99.7%
Applied egg-rr99.7%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6470.7%
Simplified70.7%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6470.7%
Applied egg-rr70.7%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6470.8%
Applied egg-rr70.8%
if -2.94999999999999991e75 < y < -1.4499999999999999e-93Initial program 94.8%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6494.9%
Simplified94.9%
Taylor expanded in x around inf
Simplified54.3%
if -1.4499999999999999e-93 < y < 3.2999999999999999e38Initial program 93.3%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6494.8%
Simplified94.8%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6464.6%
Simplified64.6%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6467.0%
Applied egg-rr67.0%
if 3.2999999999999999e38 < y Initial program 98.1%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval94.8%
Applied egg-rr94.8%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6463.1%
Simplified63.1%
frac-2negN/A
distribute-frac-negN/A
*-commutativeN/A
neg-mul-1N/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
times-fracN/A
neg-mul-1N/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
frac-2negN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f6463.1%
Applied egg-rr63.1%
div-invN/A
metadata-evalN/A
*-lowering-*.f6463.1%
Applied egg-rr63.1%
Final simplification64.8%
(FPCore (x y z t)
:precision binary64
(if (<= y -3.35e+75)
(/ -0.3333333333333333 (/ z y))
(if (<= y -5.4e-117)
x
(if (<= y 1e+40)
(* 0.3333333333333333 (/ t (* y z)))
(- 0.0 (/ y (* z 3.0)))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.35e+75) {
tmp = -0.3333333333333333 / (z / y);
} else if (y <= -5.4e-117) {
tmp = x;
} else if (y <= 1e+40) {
tmp = 0.3333333333333333 * (t / (y * z));
} else {
tmp = 0.0 - (y / (z * 3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= (-3.35d+75)) then
tmp = (-0.3333333333333333d0) / (z / y)
else if (y <= (-5.4d-117)) then
tmp = x
else if (y <= 1d+40) then
tmp = 0.3333333333333333d0 * (t / (y * z))
else
tmp = 0.0d0 - (y / (z * 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.35e+75) {
tmp = -0.3333333333333333 / (z / y);
} else if (y <= -5.4e-117) {
tmp = x;
} else if (y <= 1e+40) {
tmp = 0.3333333333333333 * (t / (y * z));
} else {
tmp = 0.0 - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -3.35e+75: tmp = -0.3333333333333333 / (z / y) elif y <= -5.4e-117: tmp = x elif y <= 1e+40: tmp = 0.3333333333333333 * (t / (y * z)) else: tmp = 0.0 - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -3.35e+75) tmp = Float64(-0.3333333333333333 / Float64(z / y)); elseif (y <= -5.4e-117) tmp = x; elseif (y <= 1e+40) tmp = Float64(0.3333333333333333 * Float64(t / Float64(y * z))); else tmp = Float64(0.0 - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -3.35e+75) tmp = -0.3333333333333333 / (z / y); elseif (y <= -5.4e-117) tmp = x; elseif (y <= 1e+40) tmp = 0.3333333333333333 * (t / (y * z)); else tmp = 0.0 - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.35e+75], N[(-0.3333333333333333 / N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -5.4e-117], x, If[LessEqual[y, 1e+40], N[(0.3333333333333333 * N[(t / N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.35 \cdot 10^{+75}:\\
\;\;\;\;\frac{-0.3333333333333333}{\frac{z}{y}}\\
\mathbf{elif}\;y \leq -5.4 \cdot 10^{-117}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 10^{+40}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{t}{y \cdot z}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -3.35e75Initial program 99.7%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval99.7%
Applied egg-rr99.7%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6470.7%
Simplified70.7%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6470.7%
Applied egg-rr70.7%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6470.8%
Applied egg-rr70.8%
if -3.35e75 < y < -5.40000000000000005e-117Initial program 95.4%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6495.5%
Simplified95.5%
Taylor expanded in x around inf
Simplified53.9%
if -5.40000000000000005e-117 < y < 1.00000000000000003e40Initial program 92.9%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6494.5%
Simplified94.5%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6465.4%
Simplified65.4%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6465.4%
Applied egg-rr65.4%
if 1.00000000000000003e40 < y Initial program 98.1%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval94.8%
Applied egg-rr94.8%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6463.1%
Simplified63.1%
frac-2negN/A
distribute-frac-negN/A
*-commutativeN/A
neg-mul-1N/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
times-fracN/A
neg-mul-1N/A
metadata-evalN/A
distribute-lft-neg-inN/A
*-commutativeN/A
frac-2negN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f6463.1%
Applied egg-rr63.1%
div-invN/A
metadata-evalN/A
*-lowering-*.f6463.1%
Applied egg-rr63.1%
Final simplification63.8%
(FPCore (x y z t)
:precision binary64
(if (<= y -4.45e+46)
(+ x (* y (/ -0.3333333333333333 z)))
(if (<= y 3.4e+38)
(+ x (/ (* t (/ 0.3333333333333333 z)) y))
(- x (/ y (* z 3.0))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -4.45e+46) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 3.4e+38) {
tmp = x + ((t * (0.3333333333333333 / z)) / y);
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= (-4.45d+46)) then
tmp = x + (y * ((-0.3333333333333333d0) / z))
else if (y <= 3.4d+38) then
tmp = x + ((t * (0.3333333333333333d0 / z)) / y)
else
tmp = x - (y / (z * 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -4.45e+46) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 3.4e+38) {
tmp = x + ((t * (0.3333333333333333 / z)) / y);
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -4.45e+46: tmp = x + (y * (-0.3333333333333333 / z)) elif y <= 3.4e+38: tmp = x + ((t * (0.3333333333333333 / z)) / y) else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -4.45e+46) tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); elseif (y <= 3.4e+38) tmp = Float64(x + Float64(Float64(t * Float64(0.3333333333333333 / z)) / y)); else tmp = Float64(x - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -4.45e+46) tmp = x + (y * (-0.3333333333333333 / z)); elseif (y <= 3.4e+38) tmp = x + ((t * (0.3333333333333333 / z)) / y); else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -4.45e+46], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.4e+38], N[(x + N[(N[(t * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.45 \cdot 10^{+46}:\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 3.4 \cdot 10^{+38}:\\
\;\;\;\;x + \frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -4.4499999999999998e46Initial program 99.7%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6499.6%
Simplified99.6%
Taylor expanded in y around inf
Simplified93.9%
if -4.4499999999999998e46 < y < 3.39999999999999996e38Initial program 93.5%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval97.2%
Applied egg-rr97.2%
Taylor expanded in x around inf
Simplified89.6%
if 3.39999999999999996e38 < y Initial program 98.1%
associate-+l-N/A
--lowering--.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Applied egg-rr99.8%
Taylor expanded in y around inf
Simplified89.7%
Final simplification90.5%
(FPCore (x y z t) :precision binary64 (if (<= y -3.3e+46) (+ x (* y (/ -0.3333333333333333 z))) (if (<= y 1.4e+72) (+ x (/ t (* y (* z 3.0)))) (- x (/ y (* z 3.0))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.3e+46) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 1.4e+72) {
tmp = x + (t / (y * (z * 3.0)));
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= (-3.3d+46)) then
tmp = x + (y * ((-0.3333333333333333d0) / z))
else if (y <= 1.4d+72) then
tmp = x + (t / (y * (z * 3.0d0)))
else
tmp = x - (y / (z * 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.3e+46) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 1.4e+72) {
tmp = x + (t / (y * (z * 3.0)));
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -3.3e+46: tmp = x + (y * (-0.3333333333333333 / z)) elif y <= 1.4e+72: tmp = x + (t / (y * (z * 3.0))) else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -3.3e+46) tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); elseif (y <= 1.4e+72) tmp = Float64(x + Float64(t / Float64(y * Float64(z * 3.0)))); else tmp = Float64(x - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -3.3e+46) tmp = x + (y * (-0.3333333333333333 / z)); elseif (y <= 1.4e+72) tmp = x + (t / (y * (z * 3.0))); else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.3e+46], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.4e+72], N[(x + N[(t / N[(y * N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.3 \cdot 10^{+46}:\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 1.4 \cdot 10^{+72}:\\
\;\;\;\;x + \frac{t}{y \cdot \left(z \cdot 3\right)}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -3.2999999999999998e46Initial program 99.7%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6499.6%
Simplified99.6%
Taylor expanded in y around inf
Simplified93.9%
if -3.2999999999999998e46 < y < 1.4e72Initial program 94.0%
Taylor expanded in x around inf
Simplified85.8%
if 1.4e72 < y Initial program 97.7%
associate-+l-N/A
--lowering--.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6499.8%
Applied egg-rr99.8%
Taylor expanded in y around inf
Simplified95.5%
Final simplification89.0%
(FPCore (x y z t)
:precision binary64
(if (<= x -1.8e+129)
(+ x (* y (/ -0.3333333333333333 z)))
(if (<= x 2.05e+24)
(* (/ 0.3333333333333333 z) (- (/ t y) y))
(- x (/ y (* z 3.0))))))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.8e+129) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (x <= 2.05e+24) {
tmp = (0.3333333333333333 / z) * ((t / y) - y);
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-1.8d+129)) then
tmp = x + (y * ((-0.3333333333333333d0) / z))
else if (x <= 2.05d+24) then
tmp = (0.3333333333333333d0 / z) * ((t / y) - y)
else
tmp = x - (y / (z * 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.8e+129) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (x <= 2.05e+24) {
tmp = (0.3333333333333333 / z) * ((t / y) - y);
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -1.8e+129: tmp = x + (y * (-0.3333333333333333 / z)) elif x <= 2.05e+24: tmp = (0.3333333333333333 / z) * ((t / y) - y) else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -1.8e+129) tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); elseif (x <= 2.05e+24) tmp = Float64(Float64(0.3333333333333333 / z) * Float64(Float64(t / y) - y)); else tmp = Float64(x - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -1.8e+129) tmp = x + (y * (-0.3333333333333333 / z)); elseif (x <= 2.05e+24) tmp = (0.3333333333333333 / z) * ((t / y) - y); else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -1.8e+129], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.05e+24], N[(N[(0.3333333333333333 / z), $MachinePrecision] * N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.8 \cdot 10^{+129}:\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;x \leq 2.05 \cdot 10^{+24}:\\
\;\;\;\;\frac{0.3333333333333333}{z} \cdot \left(\frac{t}{y} - y\right)\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if x < -1.8000000000000001e129Initial program 92.5%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6494.9%
Simplified94.9%
Taylor expanded in y around inf
Simplified72.8%
if -1.8000000000000001e129 < x < 2.05e24Initial program 96.7%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6496.7%
Simplified96.7%
Taylor expanded in x around 0
associate-*r/N/A
/-lowering-/.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
metadata-evalN/A
metadata-evalN/A
cancel-sign-sub-invN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.4%
Simplified85.4%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6485.3%
Applied egg-rr85.3%
if 2.05e24 < x Initial program 95.3%
associate-+l-N/A
--lowering--.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6498.3%
Applied egg-rr98.3%
Taylor expanded in y around inf
Simplified84.7%
Final simplification83.3%
(FPCore (x y z t) :precision binary64 (if (<= y -3.2e-114) (+ x (* y (/ -0.3333333333333333 z))) (if (<= y 1.35e-68) (/ (/ t (* z 3.0)) y) (- x (/ y (* z 3.0))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.2e-114) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 1.35e-68) {
tmp = (t / (z * 3.0)) / y;
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= (-3.2d-114)) then
tmp = x + (y * ((-0.3333333333333333d0) / z))
else if (y <= 1.35d-68) then
tmp = (t / (z * 3.0d0)) / y
else
tmp = x - (y / (z * 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.2e-114) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 1.35e-68) {
tmp = (t / (z * 3.0)) / y;
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -3.2e-114: tmp = x + (y * (-0.3333333333333333 / z)) elif y <= 1.35e-68: tmp = (t / (z * 3.0)) / y else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -3.2e-114) tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); elseif (y <= 1.35e-68) tmp = Float64(Float64(t / Float64(z * 3.0)) / y); else tmp = Float64(x - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -3.2e-114) tmp = x + (y * (-0.3333333333333333 / z)); elseif (y <= 1.35e-68) tmp = (t / (z * 3.0)) / y; else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.2e-114], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.35e-68], N[(N[(t / N[(z * 3.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.2 \cdot 10^{-114}:\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 1.35 \cdot 10^{-68}:\\
\;\;\;\;\frac{\frac{t}{z \cdot 3}}{y}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -3.2000000000000002e-114Initial program 97.5%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6497.5%
Simplified97.5%
Taylor expanded in y around inf
Simplified81.6%
if -3.2000000000000002e-114 < y < 1.3500000000000001e-68Initial program 91.2%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6494.3%
Simplified94.3%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6471.8%
Simplified71.8%
associate-/l/N/A
/-lowering-/.f64N/A
associate-*r/N/A
metadata-evalN/A
associate-/r*N/A
*-commutativeN/A
un-div-invN/A
/-lowering-/.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f6475.0%
Applied egg-rr75.0%
div-invN/A
metadata-evalN/A
*-lowering-*.f6475.0%
Applied egg-rr75.0%
if 1.3500000000000001e-68 < y Initial program 98.5%
associate-+l-N/A
--lowering--.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6498.5%
Applied egg-rr98.5%
Taylor expanded in y around inf
Simplified81.3%
Final simplification79.3%
(FPCore (x y z t)
:precision binary64
(if (<= y -3.5e-102)
(+ x (* y (/ -0.3333333333333333 z)))
(if (<= y 2.7e-69)
(* (/ t z) (/ 0.3333333333333333 y))
(- x (/ y (* z 3.0))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.5e-102) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 2.7e-69) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= (-3.5d-102)) then
tmp = x + (y * ((-0.3333333333333333d0) / z))
else if (y <= 2.7d-69) then
tmp = (t / z) * (0.3333333333333333d0 / y)
else
tmp = x - (y / (z * 3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.5e-102) {
tmp = x + (y * (-0.3333333333333333 / z));
} else if (y <= 2.7e-69) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -3.5e-102: tmp = x + (y * (-0.3333333333333333 / z)) elif y <= 2.7e-69: tmp = (t / z) * (0.3333333333333333 / y) else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -3.5e-102) tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); elseif (y <= 2.7e-69) tmp = Float64(Float64(t / z) * Float64(0.3333333333333333 / y)); else tmp = Float64(x - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -3.5e-102) tmp = x + (y * (-0.3333333333333333 / z)); elseif (y <= 2.7e-69) tmp = (t / z) * (0.3333333333333333 / y); else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -3.5e-102], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.7e-69], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.5 \cdot 10^{-102}:\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{-69}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -3.49999999999999986e-102Initial program 97.4%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6497.4%
Simplified97.4%
Taylor expanded in y around inf
Simplified83.7%
if -3.49999999999999986e-102 < y < 2.6999999999999997e-69Initial program 91.7%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6494.6%
Simplified94.6%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6470.5%
Simplified70.5%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6473.4%
Applied egg-rr73.4%
if 2.6999999999999997e-69 < y Initial program 98.5%
associate-+l-N/A
--lowering--.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6498.5%
Applied egg-rr98.5%
Taylor expanded in y around inf
Simplified81.3%
Final simplification79.3%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (* y (/ -0.3333333333333333 z)))))
(if (<= y -2.05e-100)
t_1
(if (<= y 2.7e-67) (* (/ t z) (/ 0.3333333333333333 y)) t_1))))
double code(double x, double y, double z, double t) {
double t_1 = x + (y * (-0.3333333333333333 / z));
double tmp;
if (y <= -2.05e-100) {
tmp = t_1;
} else if (y <= 2.7e-67) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = x + (y * ((-0.3333333333333333d0) / z))
if (y <= (-2.05d-100)) then
tmp = t_1
else if (y <= 2.7d-67) then
tmp = (t / z) * (0.3333333333333333d0 / y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = x + (y * (-0.3333333333333333 / z));
double tmp;
if (y <= -2.05e-100) {
tmp = t_1;
} else if (y <= 2.7e-67) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x + (y * (-0.3333333333333333 / z)) tmp = 0 if y <= -2.05e-100: tmp = t_1 elif y <= 2.7e-67: tmp = (t / z) * (0.3333333333333333 / y) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))) tmp = 0.0 if (y <= -2.05e-100) tmp = t_1; elseif (y <= 2.7e-67) tmp = Float64(Float64(t / z) * Float64(0.3333333333333333 / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x + (y * (-0.3333333333333333 / z)); tmp = 0.0; if (y <= -2.05e-100) tmp = t_1; elseif (y <= 2.7e-67) tmp = (t / z) * (0.3333333333333333 / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.05e-100], t$95$1, If[LessEqual[y, 2.7e-67], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{if}\;y \leq -2.05 \cdot 10^{-100}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{-67}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -2.0499999999999999e-100 or 2.70000000000000016e-67 < y Initial program 97.9%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6498.0%
Simplified98.0%
Taylor expanded in y around inf
Simplified82.5%
if -2.0499999999999999e-100 < y < 2.70000000000000016e-67Initial program 91.7%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6494.6%
Simplified94.6%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6470.5%
Simplified70.5%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6473.4%
Applied egg-rr73.4%
Final simplification79.3%
(FPCore (x y z t) :precision binary64 (if (<= x -2.4e+126) x (if (<= x 7.5e+23) (/ (/ y z) -3.0) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -2.4e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = (y / z) / -3.0;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-2.4d+126)) then
tmp = x
else if (x <= 7.5d+23) then
tmp = (y / z) / (-3.0d0)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -2.4e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = (y / z) / -3.0;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -2.4e+126: tmp = x elif x <= 7.5e+23: tmp = (y / z) / -3.0 else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -2.4e+126) tmp = x; elseif (x <= 7.5e+23) tmp = Float64(Float64(y / z) / -3.0); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -2.4e+126) tmp = x; elseif (x <= 7.5e+23) tmp = (y / z) / -3.0; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -2.4e+126], x, If[LessEqual[x, 7.5e+23], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.4 \cdot 10^{+126}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 7.5 \cdot 10^{+23}:\\
\;\;\;\;\frac{\frac{y}{z}}{-3}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -2.40000000000000012e126 or 7.49999999999999987e23 < x Initial program 93.4%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6497.0%
Simplified97.0%
Taylor expanded in x around inf
Simplified61.9%
if -2.40000000000000012e126 < x < 7.49999999999999987e23Initial program 97.2%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval96.0%
Applied egg-rr96.0%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6442.5%
Simplified42.5%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6442.4%
Applied egg-rr42.4%
*-commutativeN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-/r/N/A
distribute-neg-fracN/A
div-invN/A
metadata-evalN/A
associate-/r*N/A
frac-2negN/A
distribute-frac-neg2N/A
frac-2negN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval42.5%
Applied egg-rr42.5%
(FPCore (x y z t) :precision binary64 (if (<= x -2.6e+126) x (if (<= x 7.5e+23) (/ (* y -0.3333333333333333) z) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -2.6e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = (y * -0.3333333333333333) / z;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-2.6d+126)) then
tmp = x
else if (x <= 7.5d+23) then
tmp = (y * (-0.3333333333333333d0)) / z
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -2.6e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = (y * -0.3333333333333333) / z;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -2.6e+126: tmp = x elif x <= 7.5e+23: tmp = (y * -0.3333333333333333) / z else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -2.6e+126) tmp = x; elseif (x <= 7.5e+23) tmp = Float64(Float64(y * -0.3333333333333333) / z); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -2.6e+126) tmp = x; elseif (x <= 7.5e+23) tmp = (y * -0.3333333333333333) / z; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -2.6e+126], x, If[LessEqual[x, 7.5e+23], N[(N[(y * -0.3333333333333333), $MachinePrecision] / z), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.6 \cdot 10^{+126}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 7.5 \cdot 10^{+23}:\\
\;\;\;\;\frac{y \cdot -0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -2.6e126 or 7.49999999999999987e23 < x Initial program 93.4%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6497.0%
Simplified97.0%
Taylor expanded in x around inf
Simplified61.9%
if -2.6e126 < x < 7.49999999999999987e23Initial program 97.2%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6496.7%
Simplified96.7%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6442.5%
Simplified42.5%
Final simplification50.0%
(FPCore (x y z t) :precision binary64 (if (<= x -2.5e+126) x (if (<= x 7.5e+23) (/ -0.3333333333333333 (/ z y)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -2.5e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = -0.3333333333333333 / (z / y);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-2.5d+126)) then
tmp = x
else if (x <= 7.5d+23) then
tmp = (-0.3333333333333333d0) / (z / y)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -2.5e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = -0.3333333333333333 / (z / y);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -2.5e+126: tmp = x elif x <= 7.5e+23: tmp = -0.3333333333333333 / (z / y) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -2.5e+126) tmp = x; elseif (x <= 7.5e+23) tmp = Float64(-0.3333333333333333 / Float64(z / y)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -2.5e+126) tmp = x; elseif (x <= 7.5e+23) tmp = -0.3333333333333333 / (z / y); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -2.5e+126], x, If[LessEqual[x, 7.5e+23], N[(-0.3333333333333333 / N[(z / y), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.5 \cdot 10^{+126}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 7.5 \cdot 10^{+23}:\\
\;\;\;\;\frac{-0.3333333333333333}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -2.49999999999999989e126 or 7.49999999999999987e23 < x Initial program 93.4%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6497.0%
Simplified97.0%
Taylor expanded in x around inf
Simplified61.9%
if -2.49999999999999989e126 < x < 7.49999999999999987e23Initial program 97.2%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval96.0%
Applied egg-rr96.0%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6442.5%
Simplified42.5%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6442.4%
Applied egg-rr42.4%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6442.4%
Applied egg-rr42.4%
(FPCore (x y z t) :precision binary64 (if (<= x -4.5e+126) x (if (<= x 7.5e+23) (* y (/ -0.3333333333333333 z)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -4.5e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = y * (-0.3333333333333333 / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-4.5d+126)) then
tmp = x
else if (x <= 7.5d+23) then
tmp = y * ((-0.3333333333333333d0) / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -4.5e+126) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = y * (-0.3333333333333333 / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -4.5e+126: tmp = x elif x <= 7.5e+23: tmp = y * (-0.3333333333333333 / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -4.5e+126) tmp = x; elseif (x <= 7.5e+23) tmp = Float64(y * Float64(-0.3333333333333333 / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -4.5e+126) tmp = x; elseif (x <= 7.5e+23) tmp = y * (-0.3333333333333333 / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -4.5e+126], x, If[LessEqual[x, 7.5e+23], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -4.5 \cdot 10^{+126}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 7.5 \cdot 10^{+23}:\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -4.49999999999999974e126 or 7.49999999999999987e23 < x Initial program 93.4%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6497.0%
Simplified97.0%
Taylor expanded in x around inf
Simplified61.9%
if -4.49999999999999974e126 < x < 7.49999999999999987e23Initial program 97.2%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval96.0%
Applied egg-rr96.0%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6442.5%
Simplified42.5%
div-invN/A
associate-*l*N/A
metadata-evalN/A
distribute-lft-neg-inN/A
div-invN/A
*-commutativeN/A
*-lowering-*.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f6442.4%
Applied egg-rr42.4%
Final simplification49.9%
(FPCore (x y z t) :precision binary64 (if (<= x -1.25e+127) x (if (<= x 7.5e+23) (* -0.3333333333333333 (/ y z)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.25e+127) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = -0.3333333333333333 * (y / z);
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (x <= (-1.25d+127)) then
tmp = x
else if (x <= 7.5d+23) then
tmp = (-0.3333333333333333d0) * (y / z)
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (x <= -1.25e+127) {
tmp = x;
} else if (x <= 7.5e+23) {
tmp = -0.3333333333333333 * (y / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if x <= -1.25e+127: tmp = x elif x <= 7.5e+23: tmp = -0.3333333333333333 * (y / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (x <= -1.25e+127) tmp = x; elseif (x <= 7.5e+23) tmp = Float64(-0.3333333333333333 * Float64(y / z)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (x <= -1.25e+127) tmp = x; elseif (x <= 7.5e+23) tmp = -0.3333333333333333 * (y / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[x, -1.25e+127], x, If[LessEqual[x, 7.5e+23], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.25 \cdot 10^{+127}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 7.5 \cdot 10^{+23}:\\
\;\;\;\;-0.3333333333333333 \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -1.2500000000000001e127 or 7.49999999999999987e23 < x Initial program 93.4%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6497.0%
Simplified97.0%
Taylor expanded in x around inf
Simplified61.9%
if -1.2500000000000001e127 < x < 7.49999999999999987e23Initial program 97.2%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval96.0%
Applied egg-rr96.0%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6442.5%
Simplified42.5%
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6442.4%
Applied egg-rr42.4%
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ (* t (/ 0.3333333333333333 z)) y)))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t * (0.3333333333333333 / z)) / y);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + ((t * (0.3333333333333333d0 / z)) / y)
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t * (0.3333333333333333 / z)) / y);
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + ((t * (0.3333333333333333 / z)) / y)
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(Float64(t * Float64(0.3333333333333333 / z)) / y)) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + ((t * (0.3333333333333333 / z)) / y); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(t * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t \cdot \frac{0.3333333333333333}{z}}{y}
\end{array}
Initial program 95.7%
associate-/r*N/A
/-lowering-/.f64N/A
div-invN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-eval97.1%
Applied egg-rr97.1%
(FPCore (x y z t) :precision binary64 (- x (/ (/ (- y (/ t y)) z) 3.0)))
double code(double x, double y, double z, double t) {
return x - (((y - (t / y)) / z) / 3.0);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x - (((y - (t / y)) / z) / 3.0d0)
end function
public static double code(double x, double y, double z, double t) {
return x - (((y - (t / y)) / z) / 3.0);
}
def code(x, y, z, t): return x - (((y - (t / y)) / z) / 3.0)
function code(x, y, z, t) return Float64(x - Float64(Float64(Float64(y - Float64(t / y)) / z) / 3.0)) end
function tmp = code(x, y, z, t) tmp = x - (((y - (t / y)) / z) / 3.0); end
code[x_, y_, z_, t_] := N[(x - N[(N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision] / 3.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{\frac{y - \frac{t}{y}}{z}}{3}
\end{array}
Initial program 95.7%
associate-+l-N/A
--lowering--.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6496.8%
Applied egg-rr96.8%
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6496.8%
Applied egg-rr96.8%
(FPCore (x y z t) :precision binary64 (+ x (/ (- (/ t y) y) (* z 3.0))))
double code(double x, double y, double z, double t) {
return x + (((t / y) - y) / (z * 3.0));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x + (((t / y) - y) / (z * 3.0d0))
end function
public static double code(double x, double y, double z, double t) {
return x + (((t / y) - y) / (z * 3.0));
}
def code(x, y, z, t): return x + (((t / y) - y) / (z * 3.0))
function code(x, y, z, t) return Float64(x + Float64(Float64(Float64(t / y) - y) / Float64(z * 3.0))) end
function tmp = code(x, y, z, t) tmp = x + (((t / y) - y) / (z * 3.0)); end
code[x_, y_, z_, t_] := N[(x + N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{\frac{t}{y} - y}{z \cdot 3}
\end{array}
Initial program 95.7%
associate-+l-N/A
--lowering--.f64N/A
*-commutativeN/A
associate-/r*N/A
sub-divN/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6496.8%
Applied egg-rr96.8%
Final simplification96.8%
(FPCore (x y z t) :precision binary64 (+ x (* (/ -0.3333333333333333 z) (- y (/ t y)))))
double code(double x, double y, double z, double t) {
return x + ((-0.3333333333333333 / z) * (y - (t / y)));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x + (((-0.3333333333333333d0) / z) * (y - (t / y)))
end function
public static double code(double x, double y, double z, double t) {
return x + ((-0.3333333333333333 / z) * (y - (t / y)));
}
def code(x, y, z, t): return x + ((-0.3333333333333333 / z) * (y - (t / y)))
function code(x, y, z, t) return Float64(x + Float64(Float64(-0.3333333333333333 / z) * Float64(y - Float64(t / y)))) end
function tmp = code(x, y, z, t) tmp = x + ((-0.3333333333333333 / z) * (y - (t / y))); end
code[x_, y_, z_, t_] := N[(x + N[(N[(-0.3333333333333333 / z), $MachinePrecision] * N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{-0.3333333333333333}{z} \cdot \left(y - \frac{t}{y}\right)
\end{array}
Initial program 95.7%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6496.8%
Simplified96.8%
(FPCore (x y z t) :precision binary64 x)
double code(double x, double y, double z, double t) {
return x;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x
end function
public static double code(double x, double y, double z, double t) {
return x;
}
def code(x, y, z, t): return x
function code(x, y, z, t) return x end
function tmp = code(x, y, z, t) tmp = x; end
code[x_, y_, z_, t_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 95.7%
sub-negN/A
associate-+l+N/A
+-lowering-+.f64N/A
remove-double-negN/A
unsub-negN/A
neg-mul-1N/A
*-commutativeN/A
associate-*l/N/A
associate-/l*N/A
*-commutativeN/A
distribute-neg-fracN/A
neg-mul-1N/A
times-fracN/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-/r*N/A
/-lowering-/.f64N/A
metadata-evalN/A
--lowering--.f64N/A
/-lowering-/.f6496.8%
Simplified96.8%
Taylor expanded in x around inf
Simplified31.9%
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ (/ t (* z 3.0)) y)))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x - (y / (z * 3.0d0))) + ((t / (z * 3.0d0)) / y)
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y);
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y)
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(Float64(t / Float64(z * 3.0)) / y)) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + ((t / (z * 3.0)) / y); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(t / N[(z * 3.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{\frac{t}{z \cdot 3}}{y}
\end{array}
herbie shell --seed 2024161
(FPCore (x y z t)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, H"
:precision binary64
:alt
(! :herbie-platform default (+ (- x (/ y (* z 3))) (/ (/ t (* z 3)) y)))
(+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))