
(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
(let* ((t_1 (- x (/ y (* z 3.0)))))
(if (<= x -3.4e-185)
(+ t_1 (/ t (* y (* z 3.0))))
(+ t_1 (/ (* t (/ 0.3333333333333333 z)) y)))))
double code(double x, double y, double z, double t) {
double t_1 = x - (y / (z * 3.0));
double tmp;
if (x <= -3.4e-185) {
tmp = t_1 + (t / (y * (z * 3.0)));
} else {
tmp = t_1 + ((t * (0.3333333333333333 / z)) / 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) :: t_1
real(8) :: tmp
t_1 = x - (y / (z * 3.0d0))
if (x <= (-3.4d-185)) then
tmp = t_1 + (t / (y * (z * 3.0d0)))
else
tmp = t_1 + ((t * (0.3333333333333333d0 / z)) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = x - (y / (z * 3.0));
double tmp;
if (x <= -3.4e-185) {
tmp = t_1 + (t / (y * (z * 3.0)));
} else {
tmp = t_1 + ((t * (0.3333333333333333 / z)) / y);
}
return tmp;
}
def code(x, y, z, t): t_1 = x - (y / (z * 3.0)) tmp = 0 if x <= -3.4e-185: tmp = t_1 + (t / (y * (z * 3.0))) else: tmp = t_1 + ((t * (0.3333333333333333 / z)) / y) return tmp
function code(x, y, z, t) t_1 = Float64(x - Float64(y / Float64(z * 3.0))) tmp = 0.0 if (x <= -3.4e-185) tmp = Float64(t_1 + Float64(t / Float64(y * Float64(z * 3.0)))); else tmp = Float64(t_1 + Float64(Float64(t * Float64(0.3333333333333333 / z)) / y)); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x - (y / (z * 3.0)); tmp = 0.0; if (x <= -3.4e-185) tmp = t_1 + (t / (y * (z * 3.0))); else tmp = t_1 + ((t * (0.3333333333333333 / z)) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.4e-185], N[(t$95$1 + N[(t / N[(y * N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(N[(t * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{y}{z \cdot 3}\\
\mathbf{if}\;x \leq -3.4 \cdot 10^{-185}:\\
\;\;\;\;t\_1 + \frac{t}{y \cdot \left(z \cdot 3\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1 + \frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\end{array}
\end{array}
if x < -3.3999999999999998e-185Initial program 98.9%
if -3.3999999999999998e-185 < x Initial program 96.4%
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.2%
Applied egg-rr99.2%
Final simplification99.1%
(FPCore (x y z t)
:precision binary64
(if (<= y -9e-38)
(+ x (/ (/ (- y (/ t y)) -3.0) z))
(if (<= y 1.4e-62)
(+ x (/ (* 0.3333333333333333 (/ t z)) y))
(+ x (/ (- (/ t y) y) (* z 3.0))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -9e-38) {
tmp = x + (((y - (t / y)) / -3.0) / z);
} else if (y <= 1.4e-62) {
tmp = x + ((0.3333333333333333 * (t / z)) / y);
} else {
tmp = x + (((t / y) - 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 <= (-9d-38)) then
tmp = x + (((y - (t / y)) / (-3.0d0)) / z)
else if (y <= 1.4d-62) then
tmp = x + ((0.3333333333333333d0 * (t / z)) / y)
else
tmp = x + (((t / y) - 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 <= -9e-38) {
tmp = x + (((y - (t / y)) / -3.0) / z);
} else if (y <= 1.4e-62) {
tmp = x + ((0.3333333333333333 * (t / z)) / y);
} else {
tmp = x + (((t / y) - y) / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -9e-38: tmp = x + (((y - (t / y)) / -3.0) / z) elif y <= 1.4e-62: tmp = x + ((0.3333333333333333 * (t / z)) / y) else: tmp = x + (((t / y) - y) / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -9e-38) tmp = Float64(x + Float64(Float64(Float64(y - Float64(t / y)) / -3.0) / z)); elseif (y <= 1.4e-62) tmp = Float64(x + Float64(Float64(0.3333333333333333 * Float64(t / z)) / y)); else tmp = Float64(x + Float64(Float64(Float64(t / y) - y) / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -9e-38) tmp = x + (((y - (t / y)) / -3.0) / z); elseif (y <= 1.4e-62) tmp = x + ((0.3333333333333333 * (t / z)) / y); else tmp = x + (((t / y) - y) / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -9e-38], N[(x + N[(N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / -3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.4e-62], N[(x + N[(N[(0.3333333333333333 * N[(t / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9 \cdot 10^{-38}:\\
\;\;\;\;x + \frac{\frac{y - \frac{t}{y}}{-3}}{z}\\
\mathbf{elif}\;y \leq 1.4 \cdot 10^{-62}:\\
\;\;\;\;x + \frac{0.3333333333333333 \cdot \frac{t}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{\frac{t}{y} - y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -9.00000000000000018e-38Initial 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%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6499.6%
Applied egg-rr99.6%
associate-*l/N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6499.8%
Applied egg-rr99.8%
if -9.00000000000000018e-38 < y < 1.40000000000000001e-62Initial 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-/.f6485.4%
Simplified85.4%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.5%
Applied egg-rr85.5%
associate-*l/N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.4%
Applied egg-rr85.4%
Taylor expanded in y around 0
associate-/l/N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6497.6%
Simplified97.6%
if 1.40000000000000001e-62 < y Initial program 99.9%
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.8%
Applied egg-rr98.8%
Final simplification98.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (/ (/ (- y (/ t y)) -3.0) z))))
(if (<= y -9e-38)
t_1
(if (<= y 8e-63) (+ x (/ (* 0.3333333333333333 (/ t z)) y)) t_1))))
double code(double x, double y, double z, double t) {
double t_1 = x + (((y - (t / y)) / -3.0) / z);
double tmp;
if (y <= -9e-38) {
tmp = t_1;
} else if (y <= 8e-63) {
tmp = x + ((0.3333333333333333 * (t / z)) / 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 - (t / y)) / (-3.0d0)) / z)
if (y <= (-9d-38)) then
tmp = t_1
else if (y <= 8d-63) then
tmp = x + ((0.3333333333333333d0 * (t / z)) / 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 - (t / y)) / -3.0) / z);
double tmp;
if (y <= -9e-38) {
tmp = t_1;
} else if (y <= 8e-63) {
tmp = x + ((0.3333333333333333 * (t / z)) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x + (((y - (t / y)) / -3.0) / z) tmp = 0 if y <= -9e-38: tmp = t_1 elif y <= 8e-63: tmp = x + ((0.3333333333333333 * (t / z)) / y) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x + Float64(Float64(Float64(y - Float64(t / y)) / -3.0) / z)) tmp = 0.0 if (y <= -9e-38) tmp = t_1; elseif (y <= 8e-63) tmp = Float64(x + Float64(Float64(0.3333333333333333 * Float64(t / z)) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x + (((y - (t / y)) / -3.0) / z); tmp = 0.0; if (y <= -9e-38) tmp = t_1; elseif (y <= 8e-63) tmp = x + ((0.3333333333333333 * (t / z)) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / -3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9e-38], t$95$1, If[LessEqual[y, 8e-63], N[(x + N[(N[(0.3333333333333333 * N[(t / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{\frac{y - \frac{t}{y}}{-3}}{z}\\
\mathbf{if}\;y \leq -9 \cdot 10^{-38}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 8 \cdot 10^{-63}:\\
\;\;\;\;x + \frac{0.3333333333333333 \cdot \frac{t}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -9.00000000000000018e-38 or 8.00000000000000053e-63 < y Initial program 99.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-/.f6499.2%
Simplified99.2%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6499.1%
Applied egg-rr99.1%
associate-*l/N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6499.3%
Applied egg-rr99.3%
if -9.00000000000000018e-38 < y < 8.00000000000000053e-63Initial 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-/.f6485.4%
Simplified85.4%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.5%
Applied egg-rr85.5%
associate-*l/N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.4%
Applied egg-rr85.4%
Taylor expanded in y around 0
associate-/l/N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6497.6%
Simplified97.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- y (/ t y))))
(if (<= y -9e-38)
(+ x (* (/ t_1 z) -0.3333333333333333))
(if (<= y 2.5e-60)
(+ x (/ (* 0.3333333333333333 (/ t z)) y))
(+ x (* t_1 (/ -0.3333333333333333 z)))))))
double code(double x, double y, double z, double t) {
double t_1 = y - (t / y);
double tmp;
if (y <= -9e-38) {
tmp = x + ((t_1 / z) * -0.3333333333333333);
} else if (y <= 2.5e-60) {
tmp = x + ((0.3333333333333333 * (t / z)) / y);
} else {
tmp = x + (t_1 * (-0.3333333333333333 / z));
}
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 = y - (t / y)
if (y <= (-9d-38)) then
tmp = x + ((t_1 / z) * (-0.3333333333333333d0))
else if (y <= 2.5d-60) then
tmp = x + ((0.3333333333333333d0 * (t / z)) / y)
else
tmp = x + (t_1 * ((-0.3333333333333333d0) / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = y - (t / y);
double tmp;
if (y <= -9e-38) {
tmp = x + ((t_1 / z) * -0.3333333333333333);
} else if (y <= 2.5e-60) {
tmp = x + ((0.3333333333333333 * (t / z)) / y);
} else {
tmp = x + (t_1 * (-0.3333333333333333 / z));
}
return tmp;
}
def code(x, y, z, t): t_1 = y - (t / y) tmp = 0 if y <= -9e-38: tmp = x + ((t_1 / z) * -0.3333333333333333) elif y <= 2.5e-60: tmp = x + ((0.3333333333333333 * (t / z)) / y) else: tmp = x + (t_1 * (-0.3333333333333333 / z)) return tmp
function code(x, y, z, t) t_1 = Float64(y - Float64(t / y)) tmp = 0.0 if (y <= -9e-38) tmp = Float64(x + Float64(Float64(t_1 / z) * -0.3333333333333333)); elseif (y <= 2.5e-60) tmp = Float64(x + Float64(Float64(0.3333333333333333 * Float64(t / z)) / y)); else tmp = Float64(x + Float64(t_1 * Float64(-0.3333333333333333 / z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = y - (t / y); tmp = 0.0; if (y <= -9e-38) tmp = x + ((t_1 / z) * -0.3333333333333333); elseif (y <= 2.5e-60) tmp = x + ((0.3333333333333333 * (t / z)) / y); else tmp = x + (t_1 * (-0.3333333333333333 / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9e-38], N[(x + N[(N[(t$95$1 / z), $MachinePrecision] * -0.3333333333333333), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e-60], N[(x + N[(N[(0.3333333333333333 * N[(t / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(x + N[(t$95$1 * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y - \frac{t}{y}\\
\mathbf{if}\;y \leq -9 \cdot 10^{-38}:\\
\;\;\;\;x + \frac{t\_1}{z} \cdot -0.3333333333333333\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{-60}:\\
\;\;\;\;x + \frac{0.3333333333333333 \cdot \frac{t}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;x + t\_1 \cdot \frac{-0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -9.00000000000000018e-38Initial 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%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6499.6%
Applied egg-rr99.6%
if -9.00000000000000018e-38 < y < 2.5000000000000001e-60Initial 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-/.f6485.4%
Simplified85.4%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.5%
Applied egg-rr85.5%
associate-*l/N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.4%
Applied egg-rr85.4%
Taylor expanded in y around 0
associate-/l/N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6497.6%
Simplified97.6%
if 2.5000000000000001e-60 < y Initial program 99.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.7%
Simplified98.7%
Final simplification98.5%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (* (- y (/ t y)) (/ -0.3333333333333333 z)))))
(if (<= y -9e-38)
t_1
(if (<= y 5.4e-63) (+ x (/ (* 0.3333333333333333 (/ t z)) y)) t_1))))
double code(double x, double y, double z, double t) {
double t_1 = x + ((y - (t / y)) * (-0.3333333333333333 / z));
double tmp;
if (y <= -9e-38) {
tmp = t_1;
} else if (y <= 5.4e-63) {
tmp = x + ((0.3333333333333333 * (t / z)) / 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 - (t / y)) * ((-0.3333333333333333d0) / z))
if (y <= (-9d-38)) then
tmp = t_1
else if (y <= 5.4d-63) then
tmp = x + ((0.3333333333333333d0 * (t / z)) / 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 - (t / y)) * (-0.3333333333333333 / z));
double tmp;
if (y <= -9e-38) {
tmp = t_1;
} else if (y <= 5.4e-63) {
tmp = x + ((0.3333333333333333 * (t / z)) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x + ((y - (t / y)) * (-0.3333333333333333 / z)) tmp = 0 if y <= -9e-38: tmp = t_1 elif y <= 5.4e-63: tmp = x + ((0.3333333333333333 * (t / z)) / y) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x + Float64(Float64(y - Float64(t / y)) * Float64(-0.3333333333333333 / z))) tmp = 0.0 if (y <= -9e-38) tmp = t_1; elseif (y <= 5.4e-63) tmp = Float64(x + Float64(Float64(0.3333333333333333 * Float64(t / z)) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x + ((y - (t / y)) * (-0.3333333333333333 / z)); tmp = 0.0; if (y <= -9e-38) tmp = t_1; elseif (y <= 5.4e-63) tmp = x + ((0.3333333333333333 * (t / z)) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9e-38], t$95$1, If[LessEqual[y, 5.4e-63], N[(x + N[(N[(0.3333333333333333 * N[(t / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y - \frac{t}{y}\right) \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{if}\;y \leq -9 \cdot 10^{-38}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 5.4 \cdot 10^{-63}:\\
\;\;\;\;x + \frac{0.3333333333333333 \cdot \frac{t}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -9.00000000000000018e-38 or 5.4000000000000004e-63 < y Initial program 99.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-/.f6499.2%
Simplified99.2%
if -9.00000000000000018e-38 < y < 5.4000000000000004e-63Initial 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-/.f6485.4%
Simplified85.4%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.5%
Applied egg-rr85.5%
associate-*l/N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6485.4%
Applied egg-rr85.4%
Taylor expanded in y around 0
associate-/l/N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6497.6%
Simplified97.6%
Final simplification98.5%
(FPCore (x y z t)
:precision binary64
(if (<= y -6e+28)
(/ (/ y -3.0) z)
(if (<= y 6.2e-99)
(* (/ t z) (/ 0.3333333333333333 y))
(if (<= y 1.42e+23) x (/ y (/ z -0.3333333333333333))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -6e+28) {
tmp = (y / -3.0) / z;
} else if (y <= 6.2e-99) {
tmp = (t / z) * (0.3333333333333333 / y);
} else if (y <= 1.42e+23) {
tmp = x;
} else {
tmp = y / (z / -0.3333333333333333);
}
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 <= (-6d+28)) then
tmp = (y / (-3.0d0)) / z
else if (y <= 6.2d-99) then
tmp = (t / z) * (0.3333333333333333d0 / y)
else if (y <= 1.42d+23) then
tmp = x
else
tmp = y / (z / (-0.3333333333333333d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -6e+28) {
tmp = (y / -3.0) / z;
} else if (y <= 6.2e-99) {
tmp = (t / z) * (0.3333333333333333 / y);
} else if (y <= 1.42e+23) {
tmp = x;
} else {
tmp = y / (z / -0.3333333333333333);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -6e+28: tmp = (y / -3.0) / z elif y <= 6.2e-99: tmp = (t / z) * (0.3333333333333333 / y) elif y <= 1.42e+23: tmp = x else: tmp = y / (z / -0.3333333333333333) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -6e+28) tmp = Float64(Float64(y / -3.0) / z); elseif (y <= 6.2e-99) tmp = Float64(Float64(t / z) * Float64(0.3333333333333333 / y)); elseif (y <= 1.42e+23) tmp = x; else tmp = Float64(y / Float64(z / -0.3333333333333333)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -6e+28) tmp = (y / -3.0) / z; elseif (y <= 6.2e-99) tmp = (t / z) * (0.3333333333333333 / y); elseif (y <= 1.42e+23) tmp = x; else tmp = y / (z / -0.3333333333333333); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -6e+28], N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[y, 6.2e-99], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.42e+23], x, N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6 \cdot 10^{+28}:\\
\;\;\;\;\frac{\frac{y}{-3}}{z}\\
\mathbf{elif}\;y \leq 6.2 \cdot 10^{-99}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{elif}\;y \leq 1.42 \cdot 10^{+23}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{\frac{z}{-0.3333333333333333}}\\
\end{array}
\end{array}
if y < -6.0000000000000002e28Initial program 99.7%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6499.7%
Applied egg-rr99.7%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6474.3%
Simplified74.3%
/-lowering-/.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f6474.4%
Applied egg-rr74.4%
if -6.0000000000000002e28 < y < 6.1999999999999997e-99Initial program 94.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-/.f6488.0%
Simplified88.0%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6467.3%
Simplified67.3%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6469.6%
Applied egg-rr69.6%
if 6.1999999999999997e-99 < y < 1.42000000000000004e23Initial program 99.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.3%
Simplified94.3%
Taylor expanded in x around inf
Simplified55.9%
if 1.42000000000000004e23 < y Initial program 99.9%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6499.9%
Applied egg-rr99.9%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6470.0%
Simplified70.0%
metadata-evalN/A
div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f6470.2%
Applied egg-rr70.2%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (* (/ y -3.0) (/ 1.0 z)))))
(if (<= y -4e+34)
t_1
(if (<= y 31000000.0) (+ x (/ (* 0.3333333333333333 (/ t z)) y)) t_1))))
double code(double x, double y, double z, double t) {
double t_1 = x + ((y / -3.0) * (1.0 / z));
double tmp;
if (y <= -4e+34) {
tmp = t_1;
} else if (y <= 31000000.0) {
tmp = x + ((0.3333333333333333 * (t / z)) / 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 / (-3.0d0)) * (1.0d0 / z))
if (y <= (-4d+34)) then
tmp = t_1
else if (y <= 31000000.0d0) then
tmp = x + ((0.3333333333333333d0 * (t / z)) / 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 / -3.0) * (1.0 / z));
double tmp;
if (y <= -4e+34) {
tmp = t_1;
} else if (y <= 31000000.0) {
tmp = x + ((0.3333333333333333 * (t / z)) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x + ((y / -3.0) * (1.0 / z)) tmp = 0 if y <= -4e+34: tmp = t_1 elif y <= 31000000.0: tmp = x + ((0.3333333333333333 * (t / z)) / y) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x + Float64(Float64(y / -3.0) * Float64(1.0 / z))) tmp = 0.0 if (y <= -4e+34) tmp = t_1; elseif (y <= 31000000.0) tmp = Float64(x + Float64(Float64(0.3333333333333333 * Float64(t / z)) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x + ((y / -3.0) * (1.0 / z)); tmp = 0.0; if (y <= -4e+34) tmp = t_1; elseif (y <= 31000000.0) tmp = x + ((0.3333333333333333 * (t / z)) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(y / -3.0), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4e+34], t$95$1, If[LessEqual[y, 31000000.0], N[(x + N[(N[(0.3333333333333333 * N[(t / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y}{-3} \cdot \frac{1}{z}\\
\mathbf{if}\;y \leq -4 \cdot 10^{+34}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 31000000:\\
\;\;\;\;x + \frac{0.3333333333333333 \cdot \frac{t}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -3.99999999999999978e34 or 3.1e7 < y Initial program 99.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-/.f6499.7%
Simplified99.7%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
*-commutativeN/A
distribute-lft-neg-inN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
metadata-evalN/A
/-lowering-/.f6499.7%
Applied egg-rr99.7%
Taylor expanded in y around inf
Simplified94.4%
if -3.99999999999999978e34 < y < 3.1e7Initial 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-/.f6489.4%
Simplified89.4%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6489.4%
Applied egg-rr89.4%
associate-*l/N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6489.4%
Applied egg-rr89.4%
Taylor expanded in y around 0
associate-/l/N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6492.0%
Simplified92.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (* (/ y -3.0) (/ 1.0 z)))))
(if (<= y -3.4e+42)
t_1
(if (<= y 45000000000000.0) (+ x (/ t (* y (* z 3.0)))) t_1))))
double code(double x, double y, double z, double t) {
double t_1 = x + ((y / -3.0) * (1.0 / z));
double tmp;
if (y <= -3.4e+42) {
tmp = t_1;
} else if (y <= 45000000000000.0) {
tmp = x + (t / (y * (z * 3.0)));
} 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 / (-3.0d0)) * (1.0d0 / z))
if (y <= (-3.4d+42)) then
tmp = t_1
else if (y <= 45000000000000.0d0) then
tmp = x + (t / (y * (z * 3.0d0)))
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 / -3.0) * (1.0 / z));
double tmp;
if (y <= -3.4e+42) {
tmp = t_1;
} else if (y <= 45000000000000.0) {
tmp = x + (t / (y * (z * 3.0)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x + ((y / -3.0) * (1.0 / z)) tmp = 0 if y <= -3.4e+42: tmp = t_1 elif y <= 45000000000000.0: tmp = x + (t / (y * (z * 3.0))) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x + Float64(Float64(y / -3.0) * Float64(1.0 / z))) tmp = 0.0 if (y <= -3.4e+42) tmp = t_1; elseif (y <= 45000000000000.0) tmp = Float64(x + Float64(t / Float64(y * Float64(z * 3.0)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x + ((y / -3.0) * (1.0 / z)); tmp = 0.0; if (y <= -3.4e+42) tmp = t_1; elseif (y <= 45000000000000.0) tmp = x + (t / (y * (z * 3.0))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x + N[(N[(y / -3.0), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.4e+42], t$95$1, If[LessEqual[y, 45000000000000.0], N[(x + N[(t / N[(y * N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y}{-3} \cdot \frac{1}{z}\\
\mathbf{if}\;y \leq -3.4 \cdot 10^{+42}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 45000000000000:\\
\;\;\;\;x + \frac{t}{y \cdot \left(z \cdot 3\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -3.39999999999999975e42 or 4.5e13 < y Initial program 99.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-/.f6499.7%
Simplified99.7%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
*-commutativeN/A
distribute-lft-neg-inN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
metadata-evalN/A
/-lowering-/.f6499.7%
Applied egg-rr99.7%
Taylor expanded in y around inf
Simplified94.4%
if -3.39999999999999975e42 < y < 4.5e13Initial program 95.4%
Taylor expanded in x around inf
Simplified89.6%
Final simplification91.7%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (* (/ y -3.0) (/ 1.0 z)))))
(if (<= y -1.02e-28)
t_1
(if (<= y 3.5e-99) (* (/ t z) (/ 0.3333333333333333 y)) t_1))))
double code(double x, double y, double z, double t) {
double t_1 = x + ((y / -3.0) * (1.0 / z));
double tmp;
if (y <= -1.02e-28) {
tmp = t_1;
} else if (y <= 3.5e-99) {
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 / (-3.0d0)) * (1.0d0 / z))
if (y <= (-1.02d-28)) then
tmp = t_1
else if (y <= 3.5d-99) 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 / -3.0) * (1.0 / z));
double tmp;
if (y <= -1.02e-28) {
tmp = t_1;
} else if (y <= 3.5e-99) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x + ((y / -3.0) * (1.0 / z)) tmp = 0 if y <= -1.02e-28: tmp = t_1 elif y <= 3.5e-99: tmp = (t / z) * (0.3333333333333333 / y) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x + Float64(Float64(y / -3.0) * Float64(1.0 / z))) tmp = 0.0 if (y <= -1.02e-28) tmp = t_1; elseif (y <= 3.5e-99) 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 / -3.0) * (1.0 / z)); tmp = 0.0; if (y <= -1.02e-28) tmp = t_1; elseif (y <= 3.5e-99) 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[(N[(y / -3.0), $MachinePrecision] * N[(1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.02e-28], t$95$1, If[LessEqual[y, 3.5e-99], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y}{-3} \cdot \frac{1}{z}\\
\mathbf{if}\;y \leq -1.02 \cdot 10^{-28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.5 \cdot 10^{-99}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.01999999999999997e-28 or 3.4999999999999999e-99 < y Initial program 99.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-/.f6498.6%
Simplified98.6%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
*-commutativeN/A
distribute-lft-neg-inN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
metadata-evalN/A
/-lowering-/.f6498.6%
Applied egg-rr98.6%
Taylor expanded in y around inf
Simplified84.8%
if -1.01999999999999997e-28 < y < 3.4999999999999999e-99Initial 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-/.f6486.1%
Simplified86.1%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6470.0%
Simplified70.0%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6473.6%
Applied egg-rr73.6%
(FPCore (x y z t)
:precision binary64
(if (<= y -2.05e-29)
(+ x (* (/ 1.0 z) (* y -0.3333333333333333)))
(if (<= y 6.2e-99)
(* (/ t z) (/ 0.3333333333333333 y))
(+ x (* y (/ -0.3333333333333333 z))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -2.05e-29) {
tmp = x + ((1.0 / z) * (y * -0.3333333333333333));
} else if (y <= 6.2e-99) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = x + (y * (-0.3333333333333333 / z));
}
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.05d-29)) then
tmp = x + ((1.0d0 / z) * (y * (-0.3333333333333333d0)))
else if (y <= 6.2d-99) then
tmp = (t / z) * (0.3333333333333333d0 / y)
else
tmp = x + (y * ((-0.3333333333333333d0) / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -2.05e-29) {
tmp = x + ((1.0 / z) * (y * -0.3333333333333333));
} else if (y <= 6.2e-99) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = x + (y * (-0.3333333333333333 / z));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -2.05e-29: tmp = x + ((1.0 / z) * (y * -0.3333333333333333)) elif y <= 6.2e-99: tmp = (t / z) * (0.3333333333333333 / y) else: tmp = x + (y * (-0.3333333333333333 / z)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -2.05e-29) tmp = Float64(x + Float64(Float64(1.0 / z) * Float64(y * -0.3333333333333333))); elseif (y <= 6.2e-99) tmp = Float64(Float64(t / z) * Float64(0.3333333333333333 / y)); else tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -2.05e-29) tmp = x + ((1.0 / z) * (y * -0.3333333333333333)); elseif (y <= 6.2e-99) tmp = (t / z) * (0.3333333333333333 / y); else tmp = x + (y * (-0.3333333333333333 / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -2.05e-29], N[(x + N[(N[(1.0 / z), $MachinePrecision] * N[(y * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.2e-99], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.05 \cdot 10^{-29}:\\
\;\;\;\;x + \frac{1}{z} \cdot \left(y \cdot -0.3333333333333333\right)\\
\mathbf{elif}\;y \leq 6.2 \cdot 10^{-99}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -2.0499999999999999e-29Initial 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%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
*-commutativeN/A
distribute-lft-neg-inN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
metadata-evalN/A
/-lowering-/.f6499.7%
Applied egg-rr99.7%
Taylor expanded in y around inf
*-commutativeN/A
*-lowering-*.f6484.4%
Simplified84.4%
if -2.0499999999999999e-29 < y < 6.1999999999999997e-99Initial 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-/.f6486.1%
Simplified86.1%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6470.0%
Simplified70.0%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6473.6%
Applied egg-rr73.6%
if 6.1999999999999997e-99 < y Initial program 99.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-/.f6497.6%
Simplified97.6%
Taylor expanded in y around inf
Simplified85.1%
Final simplification80.5%
(FPCore (x y z t)
:precision binary64
(if (<= y -6.8e-32)
(+ x (* -0.3333333333333333 (/ y z)))
(if (<= y 1.15e-99)
(* (/ t z) (/ 0.3333333333333333 y))
(+ x (* y (/ -0.3333333333333333 z))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -6.8e-32) {
tmp = x + (-0.3333333333333333 * (y / z));
} else if (y <= 1.15e-99) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = x + (y * (-0.3333333333333333 / z));
}
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 <= (-6.8d-32)) then
tmp = x + ((-0.3333333333333333d0) * (y / z))
else if (y <= 1.15d-99) then
tmp = (t / z) * (0.3333333333333333d0 / y)
else
tmp = x + (y * ((-0.3333333333333333d0) / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= -6.8e-32) {
tmp = x + (-0.3333333333333333 * (y / z));
} else if (y <= 1.15e-99) {
tmp = (t / z) * (0.3333333333333333 / y);
} else {
tmp = x + (y * (-0.3333333333333333 / z));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -6.8e-32: tmp = x + (-0.3333333333333333 * (y / z)) elif y <= 1.15e-99: tmp = (t / z) * (0.3333333333333333 / y) else: tmp = x + (y * (-0.3333333333333333 / z)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -6.8e-32) tmp = Float64(x + Float64(-0.3333333333333333 * Float64(y / z))); elseif (y <= 1.15e-99) tmp = Float64(Float64(t / z) * Float64(0.3333333333333333 / y)); else tmp = Float64(x + Float64(y * Float64(-0.3333333333333333 / z))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -6.8e-32) tmp = x + (-0.3333333333333333 * (y / z)); elseif (y <= 1.15e-99) tmp = (t / z) * (0.3333333333333333 / y); else tmp = x + (y * (-0.3333333333333333 / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -6.8e-32], N[(x + N[(-0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.15e-99], N[(N[(t / z), $MachinePrecision] * N[(0.3333333333333333 / y), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.8 \cdot 10^{-32}:\\
\;\;\;\;x + -0.3333333333333333 \cdot \frac{y}{z}\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{-99}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \frac{-0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -6.79999999999999956e-32Initial 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%
*-commutativeN/A
clear-numN/A
div-invN/A
metadata-evalN/A
metadata-evalN/A
distribute-rgt-neg-inN/A
associate-*r/N/A
distribute-rgt-neg-inN/A
times-fracN/A
metadata-evalN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f6499.6%
Applied egg-rr99.6%
Taylor expanded in y around inf
/-lowering-/.f6484.4%
Simplified84.4%
if -6.79999999999999956e-32 < y < 1.1499999999999999e-99Initial 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-/.f6486.1%
Simplified86.1%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6470.0%
Simplified70.0%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6473.6%
Applied egg-rr73.6%
if 1.1499999999999999e-99 < y Initial program 99.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-/.f6497.6%
Simplified97.6%
Taylor expanded in y around inf
Simplified85.1%
Final simplification80.5%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ x (* y (/ -0.3333333333333333 z)))))
(if (<= y -2.1e-31)
t_1
(if (<= y 6e-99) (* (/ 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.1e-31) {
tmp = t_1;
} else if (y <= 6e-99) {
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.1d-31)) then
tmp = t_1
else if (y <= 6d-99) 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.1e-31) {
tmp = t_1;
} else if (y <= 6e-99) {
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.1e-31: tmp = t_1 elif y <= 6e-99: 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.1e-31) tmp = t_1; elseif (y <= 6e-99) 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.1e-31) tmp = t_1; elseif (y <= 6e-99) 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.1e-31], t$95$1, If[LessEqual[y, 6e-99], 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.1 \cdot 10^{-31}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 6 \cdot 10^{-99}:\\
\;\;\;\;\frac{t}{z} \cdot \frac{0.3333333333333333}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -2.09999999999999991e-31 or 6.00000000000000012e-99 < y Initial program 99.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-/.f6498.6%
Simplified98.6%
Taylor expanded in y around inf
Simplified84.7%
if -2.09999999999999991e-31 < y < 6.00000000000000012e-99Initial 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-/.f6486.1%
Simplified86.1%
Taylor expanded in y around 0
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6470.0%
Simplified70.0%
*-commutativeN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6473.6%
Applied egg-rr73.6%
Final simplification80.5%
(FPCore (x y z t) :precision binary64 (if (<= z -1.2e+131) x (if (<= z 3.9e+124) (/ (/ y -3.0) z) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -1.2e+131) {
tmp = x;
} else if (z <= 3.9e+124) {
tmp = (y / -3.0) / 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 (z <= (-1.2d+131)) then
tmp = x
else if (z <= 3.9d+124) then
tmp = (y / (-3.0d0)) / 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 (z <= -1.2e+131) {
tmp = x;
} else if (z <= 3.9e+124) {
tmp = (y / -3.0) / z;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -1.2e+131: tmp = x elif z <= 3.9e+124: tmp = (y / -3.0) / z else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -1.2e+131) tmp = x; elseif (z <= 3.9e+124) tmp = Float64(Float64(y / -3.0) / z); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -1.2e+131) tmp = x; elseif (z <= 3.9e+124) tmp = (y / -3.0) / z; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -1.2e+131], x, If[LessEqual[z, 3.9e+124], N[(N[(y / -3.0), $MachinePrecision] / z), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.2 \cdot 10^{+131}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 3.9 \cdot 10^{+124}:\\
\;\;\;\;\frac{\frac{y}{-3}}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.2e131 or 3.9e124 < z Initial program 99.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-/.f6484.2%
Simplified84.2%
Taylor expanded in x around inf
Simplified63.7%
if -1.2e131 < z < 3.9e124Initial program 96.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6496.2%
Applied egg-rr96.2%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6445.9%
Simplified45.9%
/-lowering-/.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f6445.9%
Applied egg-rr45.9%
(FPCore (x y z t) :precision binary64 (if (<= z -1.15e+131) x (if (<= z 2.5e+125) (/ y (/ z -0.3333333333333333)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -1.15e+131) {
tmp = x;
} else if (z <= 2.5e+125) {
tmp = y / (z / -0.3333333333333333);
} 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 (z <= (-1.15d+131)) then
tmp = x
else if (z <= 2.5d+125) then
tmp = y / (z / (-0.3333333333333333d0))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (z <= -1.15e+131) {
tmp = x;
} else if (z <= 2.5e+125) {
tmp = y / (z / -0.3333333333333333);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -1.15e+131: tmp = x elif z <= 2.5e+125: tmp = y / (z / -0.3333333333333333) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -1.15e+131) tmp = x; elseif (z <= 2.5e+125) tmp = Float64(y / Float64(z / -0.3333333333333333)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -1.15e+131) tmp = x; elseif (z <= 2.5e+125) tmp = y / (z / -0.3333333333333333); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -1.15e+131], x, If[LessEqual[z, 2.5e+125], N[(y / N[(z / -0.3333333333333333), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.15 \cdot 10^{+131}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{+125}:\\
\;\;\;\;\frac{y}{\frac{z}{-0.3333333333333333}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.14999999999999996e131 or 2.49999999999999981e125 < z Initial program 99.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-/.f6484.2%
Simplified84.2%
Taylor expanded in x around inf
Simplified63.7%
if -1.14999999999999996e131 < z < 2.49999999999999981e125Initial program 96.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6496.2%
Applied egg-rr96.2%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6445.9%
Simplified45.9%
metadata-evalN/A
div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
metadata-evalN/A
div-invN/A
/-lowering-/.f6445.9%
Applied egg-rr45.9%
(FPCore (x y z t) :precision binary64 (if (<= z -8.5e+130) x (if (<= z 2.9e+124) (/ -0.3333333333333333 (/ z y)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -8.5e+130) {
tmp = x;
} else if (z <= 2.9e+124) {
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 (z <= (-8.5d+130)) then
tmp = x
else if (z <= 2.9d+124) 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 (z <= -8.5e+130) {
tmp = x;
} else if (z <= 2.9e+124) {
tmp = -0.3333333333333333 / (z / y);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -8.5e+130: tmp = x elif z <= 2.9e+124: tmp = -0.3333333333333333 / (z / y) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -8.5e+130) tmp = x; elseif (z <= 2.9e+124) 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 (z <= -8.5e+130) tmp = x; elseif (z <= 2.9e+124) tmp = -0.3333333333333333 / (z / y); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -8.5e+130], x, If[LessEqual[z, 2.9e+124], N[(-0.3333333333333333 / N[(z / y), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.5 \cdot 10^{+130}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 2.9 \cdot 10^{+124}:\\
\;\;\;\;\frac{-0.3333333333333333}{\frac{z}{y}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -8.49999999999999965e130 or 2.90000000000000021e124 < z Initial program 99.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-/.f6484.2%
Simplified84.2%
Taylor expanded in x around inf
Simplified63.7%
if -8.49999999999999965e130 < z < 2.90000000000000021e124Initial program 96.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6496.2%
Applied egg-rr96.2%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6445.9%
Simplified45.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6445.8%
Applied egg-rr45.8%
associate-*l/N/A
associate-/l*N/A
clear-numN/A
div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6445.9%
Applied egg-rr45.9%
(FPCore (x y z t) :precision binary64 (if (<= z -1.05e+131) x (if (<= z 4.5e+124) (* y (/ -0.3333333333333333 z)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -1.05e+131) {
tmp = x;
} else if (z <= 4.5e+124) {
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 (z <= (-1.05d+131)) then
tmp = x
else if (z <= 4.5d+124) 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 (z <= -1.05e+131) {
tmp = x;
} else if (z <= 4.5e+124) {
tmp = y * (-0.3333333333333333 / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -1.05e+131: tmp = x elif z <= 4.5e+124: tmp = y * (-0.3333333333333333 / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -1.05e+131) tmp = x; elseif (z <= 4.5e+124) 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 (z <= -1.05e+131) tmp = x; elseif (z <= 4.5e+124) tmp = y * (-0.3333333333333333 / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -1.05e+131], x, If[LessEqual[z, 4.5e+124], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.05 \cdot 10^{+131}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{+124}:\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.04999999999999993e131 or 4.5000000000000004e124 < z Initial program 99.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-/.f6484.2%
Simplified84.2%
Taylor expanded in x around inf
Simplified63.7%
if -1.04999999999999993e131 < z < 4.5000000000000004e124Initial program 96.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6496.2%
Applied egg-rr96.2%
Taylor expanded in y around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6445.9%
Simplified45.9%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6445.8%
Applied egg-rr45.8%
Final simplification51.3%
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* y (* z 3.0)))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (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 / (z * 3.0d0))) + (t / (y * (z * 3.0d0)))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / (y * (z * 3.0)));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / (y * (z * 3.0)))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(y * Float64(z * 3.0)))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / (y * (z * 3.0))); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(y * N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{y \cdot \left(z \cdot 3\right)}
\end{array}
Initial program 97.3%
Final simplification97.3%
(FPCore (x y z t) :precision binary64 (+ (- x (/ y (* z 3.0))) (/ t (* 3.0 (* y z)))))
double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / (3.0 * (y * z)));
}
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 / (3.0d0 * (y * z)))
end function
public static double code(double x, double y, double z, double t) {
return (x - (y / (z * 3.0))) + (t / (3.0 * (y * z)));
}
def code(x, y, z, t): return (x - (y / (z * 3.0))) + (t / (3.0 * (y * z)))
function code(x, y, z, t) return Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(3.0 * Float64(y * z)))) end
function tmp = code(x, y, z, t) tmp = (x - (y / (z * 3.0))) + (t / (3.0 * (y * z))); end
code[x_, y_, z_, t_] := N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(3.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{3 \cdot \left(y \cdot z\right)}
\end{array}
Initial program 97.3%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6497.3%
Applied egg-rr97.3%
Final simplification97.3%
(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 97.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-/.f6493.8%
Simplified93.8%
Taylor expanded in x around inf
Simplified29.1%
(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 2024155
(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))))