
(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 22 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 (or (<= (* z 3.0) -4e+37) (not (<= (* z 3.0) 2e-106))) (+ (- x (/ y (* z 3.0))) (/ t (* 3.0 (* z y)))) (- x (/ (- y (/ t y)) (* z 3.0)))))
double code(double x, double y, double z, double t) {
double tmp;
if (((z * 3.0) <= -4e+37) || !((z * 3.0) <= 2e-106)) {
tmp = (x - (y / (z * 3.0))) + (t / (3.0 * (z * y)));
} else {
tmp = x - ((y - (t / 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 (((z * 3.0d0) <= (-4d+37)) .or. (.not. ((z * 3.0d0) <= 2d-106))) then
tmp = (x - (y / (z * 3.0d0))) + (t / (3.0d0 * (z * y)))
else
tmp = x - ((y - (t / 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 (((z * 3.0) <= -4e+37) || !((z * 3.0) <= 2e-106)) {
tmp = (x - (y / (z * 3.0))) + (t / (3.0 * (z * y)));
} else {
tmp = x - ((y - (t / y)) / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((z * 3.0) <= -4e+37) or not ((z * 3.0) <= 2e-106): tmp = (x - (y / (z * 3.0))) + (t / (3.0 * (z * y))) else: tmp = x - ((y - (t / y)) / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(z * 3.0) <= -4e+37) || !(Float64(z * 3.0) <= 2e-106)) tmp = Float64(Float64(x - Float64(y / Float64(z * 3.0))) + Float64(t / Float64(3.0 * Float64(z * y)))); else tmp = Float64(x - Float64(Float64(y - Float64(t / y)) / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((z * 3.0) <= -4e+37) || ~(((z * 3.0) <= 2e-106))) tmp = (x - (y / (z * 3.0))) + (t / (3.0 * (z * y))); else tmp = x - ((y - (t / y)) / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(z * 3.0), $MachinePrecision], -4e+37], N[Not[LessEqual[N[(z * 3.0), $MachinePrecision], 2e-106]], $MachinePrecision]], N[(N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t / N[(3.0 * N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -4 \cdot 10^{+37} \lor \neg \left(z \cdot 3 \leq 2 \cdot 10^{-106}\right):\\
\;\;\;\;\left(x - \frac{y}{z \cdot 3}\right) + \frac{t}{3 \cdot \left(z \cdot y\right)}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y - \frac{t}{y}}{z \cdot 3}\\
\end{array}
\end{array}
if (*.f64 z 3) < -3.99999999999999982e37 or 1.99999999999999988e-106 < (*.f64 z 3) Initial program 99.8%
Taylor expanded in z around 0 99.9%
if -3.99999999999999982e37 < (*.f64 z 3) < 1.99999999999999988e-106Initial program 84.4%
associate-+l-84.4%
sub-neg84.4%
sub-neg84.4%
distribute-frac-neg84.4%
distribute-neg-in84.4%
distribute-frac-neg84.4%
sub-neg84.4%
neg-mul-184.4%
associate-*l/84.4%
neg-mul-184.4%
times-frac97.1%
distribute-lft-out--99.8%
*-commutative99.8%
associate-/r*99.7%
metadata-eval99.7%
Simplified99.7%
sub-neg99.7%
distribute-rgt-in97.1%
div-inv97.1%
*-commutative97.1%
associate-*l*97.1%
div-inv97.1%
*-commutative97.1%
metadata-eval97.1%
metadata-eval97.1%
times-frac97.1%
metadata-eval97.1%
neg-mul-197.1%
*-commutative97.1%
distribute-neg-frac97.1%
distribute-neg-frac97.1%
clear-num97.1%
div-inv97.1%
metadata-eval97.1%
metadata-eval97.1%
distribute-rgt-neg-in97.1%
times-frac84.4%
*-commutative84.4%
times-frac92.0%
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (x y z t) :precision binary64 (if (<= (* z 3.0) -4e+37) (+ x (+ (* -0.3333333333333333 (/ y z)) (/ (/ t z) (* 3.0 y)))) (- x (/ (- y (/ t y)) (* z 3.0)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z * 3.0) <= -4e+37) {
tmp = x + ((-0.3333333333333333 * (y / z)) + ((t / z) / (3.0 * y)));
} else {
tmp = x - ((y - (t / 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 ((z * 3.0d0) <= (-4d+37)) then
tmp = x + (((-0.3333333333333333d0) * (y / z)) + ((t / z) / (3.0d0 * y)))
else
tmp = x - ((y - (t / 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 ((z * 3.0) <= -4e+37) {
tmp = x + ((-0.3333333333333333 * (y / z)) + ((t / z) / (3.0 * y)));
} else {
tmp = x - ((y - (t / y)) / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z * 3.0) <= -4e+37: tmp = x + ((-0.3333333333333333 * (y / z)) + ((t / z) / (3.0 * y))) else: tmp = x - ((y - (t / y)) / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(z * 3.0) <= -4e+37) tmp = Float64(x + Float64(Float64(-0.3333333333333333 * Float64(y / z)) + Float64(Float64(t / z) / Float64(3.0 * y)))); else tmp = Float64(x - Float64(Float64(y - Float64(t / y)) / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z * 3.0) <= -4e+37) tmp = x + ((-0.3333333333333333 * (y / z)) + ((t / z) / (3.0 * y))); else tmp = x - ((y - (t / y)) / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(z * 3.0), $MachinePrecision], -4e+37], N[(x + N[(N[(-0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision] + N[(N[(t / z), $MachinePrecision] / N[(3.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -4 \cdot 10^{+37}:\\
\;\;\;\;x + \left(-0.3333333333333333 \cdot \frac{y}{z} + \frac{\frac{t}{z}}{3 \cdot y}\right)\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y - \frac{t}{y}}{z \cdot 3}\\
\end{array}
\end{array}
if (*.f64 z 3) < -3.99999999999999982e37Initial program 99.8%
remove-double-neg99.8%
distribute-frac-neg99.8%
sub-neg99.8%
sub-neg99.8%
distribute-frac-neg99.8%
associate-+r-99.8%
sub-neg99.8%
neg-mul-199.8%
*-commutative99.8%
times-frac99.6%
metadata-eval99.6%
distribute-frac-neg99.6%
remove-double-neg99.6%
associate-*l*99.6%
*-commutative99.6%
associate-/r*98.0%
Simplified98.0%
if -3.99999999999999982e37 < (*.f64 z 3) Initial program 91.1%
associate-+l-91.1%
sub-neg91.1%
sub-neg91.1%
distribute-frac-neg91.1%
distribute-neg-in91.1%
distribute-frac-neg91.1%
sub-neg91.1%
neg-mul-191.1%
associate-*l/91.1%
neg-mul-191.1%
times-frac95.9%
distribute-lft-out--97.4%
*-commutative97.4%
associate-/r*97.4%
metadata-eval97.4%
Simplified97.4%
sub-neg97.4%
distribute-rgt-in95.9%
div-inv95.9%
*-commutative95.9%
associate-*l*95.9%
div-inv95.9%
*-commutative95.9%
metadata-eval95.9%
metadata-eval95.9%
times-frac96.0%
metadata-eval96.0%
neg-mul-196.0%
*-commutative96.0%
distribute-neg-frac96.0%
distribute-neg-frac96.0%
clear-num95.9%
div-inv96.0%
metadata-eval96.0%
metadata-eval96.0%
distribute-rgt-neg-in96.0%
times-frac91.1%
*-commutative91.1%
times-frac94.5%
Applied egg-rr97.5%
Final simplification97.6%
(FPCore (x y z t) :precision binary64 (if (or (<= (* z 3.0) -2e+40) (not (<= (* z 3.0) 2e+96))) (- x (/ y (* z 3.0))) (* -0.3333333333333333 (/ (- y (/ t y)) z))))
double code(double x, double y, double z, double t) {
double tmp;
if (((z * 3.0) <= -2e+40) || !((z * 3.0) <= 2e+96)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = -0.3333333333333333 * ((y - (t / y)) / 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 (((z * 3.0d0) <= (-2d+40)) .or. (.not. ((z * 3.0d0) <= 2d+96))) then
tmp = x - (y / (z * 3.0d0))
else
tmp = (-0.3333333333333333d0) * ((y - (t / y)) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((z * 3.0) <= -2e+40) || !((z * 3.0) <= 2e+96)) {
tmp = x - (y / (z * 3.0));
} else {
tmp = -0.3333333333333333 * ((y - (t / y)) / z);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((z * 3.0) <= -2e+40) or not ((z * 3.0) <= 2e+96): tmp = x - (y / (z * 3.0)) else: tmp = -0.3333333333333333 * ((y - (t / y)) / z) return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(z * 3.0) <= -2e+40) || !(Float64(z * 3.0) <= 2e+96)) tmp = Float64(x - Float64(y / Float64(z * 3.0))); else tmp = Float64(-0.3333333333333333 * Float64(Float64(y - Float64(t / y)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((z * 3.0) <= -2e+40) || ~(((z * 3.0) <= 2e+96))) tmp = x - (y / (z * 3.0)); else tmp = -0.3333333333333333 * ((y - (t / y)) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(z * 3.0), $MachinePrecision], -2e+40], N[Not[LessEqual[N[(z * 3.0), $MachinePrecision], 2e+96]], $MachinePrecision]], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.3333333333333333 * N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -2 \cdot 10^{+40} \lor \neg \left(z \cdot 3 \leq 2 \cdot 10^{+96}\right):\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\mathbf{else}:\\
\;\;\;\;-0.3333333333333333 \cdot \frac{y - \frac{t}{y}}{z}\\
\end{array}
\end{array}
if (*.f64 z 3) < -2.00000000000000006e40 or 2.0000000000000001e96 < (*.f64 z 3) Initial program 99.8%
Taylor expanded in t around 0 77.7%
*-commutative77.7%
metadata-eval77.7%
div-inv77.7%
associate-/r*77.8%
Applied egg-rr77.8%
if -2.00000000000000006e40 < (*.f64 z 3) < 2.0000000000000001e96Initial program 88.7%
associate-+l-88.7%
sub-neg88.7%
sub-neg88.7%
distribute-frac-neg88.7%
distribute-neg-in88.7%
distribute-frac-neg88.7%
sub-neg88.7%
neg-mul-188.7%
associate-*l/88.6%
neg-mul-188.6%
times-frac97.2%
distribute-lft-out--99.1%
*-commutative99.1%
associate-/r*99.1%
metadata-eval99.1%
Simplified99.1%
sub-neg99.1%
distribute-rgt-in97.2%
div-inv97.2%
*-commutative97.2%
associate-*l*97.2%
div-inv97.2%
*-commutative97.2%
metadata-eval97.2%
metadata-eval97.2%
times-frac97.3%
metadata-eval97.3%
neg-mul-197.3%
*-commutative97.3%
distribute-neg-frac97.3%
distribute-neg-frac97.3%
clear-num97.2%
div-inv97.3%
metadata-eval97.3%
metadata-eval97.3%
distribute-rgt-neg-in97.3%
times-frac88.7%
*-commutative88.7%
times-frac94.1%
Applied egg-rr99.2%
Taylor expanded in x around 0 91.9%
Final simplification86.5%
(FPCore (x y z t) :precision binary64 (if (or (<= (* z 3.0) -4e+37) (not (<= (* z 3.0) 2e+65))) (+ x (* 0.3333333333333333 (/ t (* z y)))) (* -0.3333333333333333 (/ (- y (/ t y)) z))))
double code(double x, double y, double z, double t) {
double tmp;
if (((z * 3.0) <= -4e+37) || !((z * 3.0) <= 2e+65)) {
tmp = x + (0.3333333333333333 * (t / (z * y)));
} else {
tmp = -0.3333333333333333 * ((y - (t / y)) / 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 (((z * 3.0d0) <= (-4d+37)) .or. (.not. ((z * 3.0d0) <= 2d+65))) then
tmp = x + (0.3333333333333333d0 * (t / (z * y)))
else
tmp = (-0.3333333333333333d0) * ((y - (t / y)) / z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((z * 3.0) <= -4e+37) || !((z * 3.0) <= 2e+65)) {
tmp = x + (0.3333333333333333 * (t / (z * y)));
} else {
tmp = -0.3333333333333333 * ((y - (t / y)) / z);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((z * 3.0) <= -4e+37) or not ((z * 3.0) <= 2e+65): tmp = x + (0.3333333333333333 * (t / (z * y))) else: tmp = -0.3333333333333333 * ((y - (t / y)) / z) return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(z * 3.0) <= -4e+37) || !(Float64(z * 3.0) <= 2e+65)) tmp = Float64(x + Float64(0.3333333333333333 * Float64(t / Float64(z * y)))); else tmp = Float64(-0.3333333333333333 * Float64(Float64(y - Float64(t / y)) / z)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((z * 3.0) <= -4e+37) || ~(((z * 3.0) <= 2e+65))) tmp = x + (0.3333333333333333 * (t / (z * y))); else tmp = -0.3333333333333333 * ((y - (t / y)) / z); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(z * 3.0), $MachinePrecision], -4e+37], N[Not[LessEqual[N[(z * 3.0), $MachinePrecision], 2e+65]], $MachinePrecision]], N[(x + N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.3333333333333333 * N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -4 \cdot 10^{+37} \lor \neg \left(z \cdot 3 \leq 2 \cdot 10^{+65}\right):\\
\;\;\;\;x + 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{else}:\\
\;\;\;\;-0.3333333333333333 \cdot \frac{y - \frac{t}{y}}{z}\\
\end{array}
\end{array}
if (*.f64 z 3) < -3.99999999999999982e37 or 2e65 < (*.f64 z 3) Initial program 99.8%
associate-+l-99.8%
sub-neg99.8%
sub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-in99.8%
distribute-frac-neg99.8%
sub-neg99.8%
neg-mul-199.8%
associate-*l/99.7%
neg-mul-199.7%
times-frac88.1%
distribute-lft-out--88.1%
*-commutative88.1%
associate-/r*88.1%
metadata-eval88.1%
Simplified88.1%
Taylor expanded in y around 0 85.4%
if -3.99999999999999982e37 < (*.f64 z 3) < 2e65Initial program 87.6%
associate-+l-87.6%
sub-neg87.6%
sub-neg87.6%
distribute-frac-neg87.6%
distribute-neg-in87.6%
distribute-frac-neg87.6%
sub-neg87.6%
neg-mul-187.6%
associate-*l/87.6%
neg-mul-187.6%
times-frac97.6%
distribute-lft-out--99.7%
*-commutative99.7%
associate-/r*99.7%
metadata-eval99.7%
Simplified99.7%
sub-neg99.7%
distribute-rgt-in97.6%
div-inv97.6%
*-commutative97.6%
associate-*l*97.6%
div-inv97.6%
*-commutative97.6%
metadata-eval97.6%
metadata-eval97.6%
times-frac97.6%
metadata-eval97.6%
neg-mul-197.6%
*-commutative97.6%
distribute-neg-frac97.6%
distribute-neg-frac97.6%
clear-num97.6%
div-inv97.7%
metadata-eval97.7%
metadata-eval97.7%
distribute-rgt-neg-in97.7%
times-frac87.6%
*-commutative87.6%
times-frac93.6%
Applied egg-rr99.8%
Taylor expanded in x around 0 93.9%
Final simplification90.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* 0.3333333333333333 (/ t (* z y)))))
(if (<= y -2.15e-15)
(/ (/ y z) -3.0)
(if (<= y 1.9e-205)
t_1
(if (<= y 4.1e-188)
x
(if (<= y 1.15e-122) t_1 (if (<= y 6.8e+99) x (/ y (* z -3.0)))))))))
double code(double x, double y, double z, double t) {
double t_1 = 0.3333333333333333 * (t / (z * y));
double tmp;
if (y <= -2.15e-15) {
tmp = (y / z) / -3.0;
} else if (y <= 1.9e-205) {
tmp = t_1;
} else if (y <= 4.1e-188) {
tmp = x;
} else if (y <= 1.15e-122) {
tmp = t_1;
} else if (y <= 6.8e+99) {
tmp = x;
} else {
tmp = 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) :: t_1
real(8) :: tmp
t_1 = 0.3333333333333333d0 * (t / (z * y))
if (y <= (-2.15d-15)) then
tmp = (y / z) / (-3.0d0)
else if (y <= 1.9d-205) then
tmp = t_1
else if (y <= 4.1d-188) then
tmp = x
else if (y <= 1.15d-122) then
tmp = t_1
else if (y <= 6.8d+99) then
tmp = x
else
tmp = y / (z * (-3.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = 0.3333333333333333 * (t / (z * y));
double tmp;
if (y <= -2.15e-15) {
tmp = (y / z) / -3.0;
} else if (y <= 1.9e-205) {
tmp = t_1;
} else if (y <= 4.1e-188) {
tmp = x;
} else if (y <= 1.15e-122) {
tmp = t_1;
} else if (y <= 6.8e+99) {
tmp = x;
} else {
tmp = y / (z * -3.0);
}
return tmp;
}
def code(x, y, z, t): t_1 = 0.3333333333333333 * (t / (z * y)) tmp = 0 if y <= -2.15e-15: tmp = (y / z) / -3.0 elif y <= 1.9e-205: tmp = t_1 elif y <= 4.1e-188: tmp = x elif y <= 1.15e-122: tmp = t_1 elif y <= 6.8e+99: tmp = x else: tmp = y / (z * -3.0) return tmp
function code(x, y, z, t) t_1 = Float64(0.3333333333333333 * Float64(t / Float64(z * y))) tmp = 0.0 if (y <= -2.15e-15) tmp = Float64(Float64(y / z) / -3.0); elseif (y <= 1.9e-205) tmp = t_1; elseif (y <= 4.1e-188) tmp = x; elseif (y <= 1.15e-122) tmp = t_1; elseif (y <= 6.8e+99) tmp = x; else tmp = Float64(y / Float64(z * -3.0)); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = 0.3333333333333333 * (t / (z * y)); tmp = 0.0; if (y <= -2.15e-15) tmp = (y / z) / -3.0; elseif (y <= 1.9e-205) tmp = t_1; elseif (y <= 4.1e-188) tmp = x; elseif (y <= 1.15e-122) tmp = t_1; elseif (y <= 6.8e+99) tmp = x; else tmp = y / (z * -3.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.15e-15], N[(N[(y / z), $MachinePrecision] / -3.0), $MachinePrecision], If[LessEqual[y, 1.9e-205], t$95$1, If[LessEqual[y, 4.1e-188], x, If[LessEqual[y, 1.15e-122], t$95$1, If[LessEqual[y, 6.8e+99], x, N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{if}\;y \leq -2.15 \cdot 10^{-15}:\\
\;\;\;\;\frac{\frac{y}{z}}{-3}\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{-205}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 4.1 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{-122}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 6.8 \cdot 10^{+99}:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{z \cdot -3}\\
\end{array}
\end{array}
if y < -2.1499999999999998e-15Initial program 96.6%
associate-+l-96.6%
sub-neg96.6%
sub-neg96.6%
distribute-frac-neg96.6%
distribute-neg-in96.6%
distribute-frac-neg96.6%
sub-neg96.6%
neg-mul-196.6%
associate-*l/96.5%
neg-mul-196.5%
times-frac96.5%
distribute-lft-out--99.8%
*-commutative99.8%
associate-/r*99.8%
metadata-eval99.8%
Simplified99.8%
sub-neg99.8%
distribute-rgt-in96.5%
div-inv96.5%
*-commutative96.5%
associate-*l*96.4%
div-inv96.5%
*-commutative96.5%
metadata-eval96.5%
metadata-eval96.5%
times-frac96.6%
metadata-eval96.6%
neg-mul-196.6%
*-commutative96.6%
distribute-neg-frac96.6%
distribute-neg-frac96.6%
clear-num96.6%
div-inv96.6%
metadata-eval96.6%
metadata-eval96.6%
distribute-rgt-neg-in96.6%
times-frac96.6%
*-commutative96.6%
times-frac91.9%
Applied egg-rr99.8%
Taylor expanded in x around 0 82.2%
Taylor expanded in y around inf 72.1%
associate-*r/72.1%
*-commutative72.1%
associate-*r/72.2%
Simplified72.2%
associate-*r/72.1%
associate-/l*72.1%
div-inv72.2%
associate-/r*72.2%
metadata-eval72.2%
Applied egg-rr72.2%
if -2.1499999999999998e-15 < y < 1.89999999999999996e-205 or 4.09999999999999982e-188 < y < 1.15000000000000003e-122Initial program 86.2%
associate-+l-86.2%
sub-neg86.2%
sub-neg86.2%
distribute-frac-neg86.2%
distribute-neg-in86.2%
distribute-frac-neg86.2%
sub-neg86.2%
neg-mul-186.2%
associate-*l/86.2%
neg-mul-186.2%
times-frac88.1%
distribute-lft-out--88.1%
*-commutative88.1%
associate-/r*88.1%
metadata-eval88.1%
Simplified88.1%
sub-neg88.1%
distribute-rgt-in88.1%
div-inv88.1%
*-commutative88.1%
associate-*l*88.1%
div-inv88.1%
*-commutative88.1%
metadata-eval88.1%
metadata-eval88.1%
times-frac88.1%
metadata-eval88.1%
neg-mul-188.1%
*-commutative88.1%
distribute-neg-frac88.1%
distribute-neg-frac88.1%
clear-num88.1%
div-inv88.1%
metadata-eval88.1%
metadata-eval88.1%
distribute-rgt-neg-in88.1%
times-frac86.2%
*-commutative86.2%
times-frac96.7%
Applied egg-rr88.2%
Taylor expanded in y around 0 66.3%
if 1.89999999999999996e-205 < y < 4.09999999999999982e-188 or 1.15000000000000003e-122 < y < 6.79999999999999968e99Initial program 97.3%
associate-+l-97.3%
sub-neg97.3%
sub-neg97.3%
distribute-frac-neg97.3%
distribute-neg-in97.3%
distribute-frac-neg97.3%
sub-neg97.3%
neg-mul-197.3%
associate-*l/97.3%
neg-mul-197.3%
times-frac96.5%
distribute-lft-out--96.5%
*-commutative96.5%
associate-/r*96.5%
metadata-eval96.5%
Simplified96.5%
Taylor expanded in x around inf 59.9%
if 6.79999999999999968e99 < y Initial program 97.4%
associate-+l-97.4%
sub-neg97.4%
sub-neg97.4%
distribute-frac-neg97.4%
distribute-neg-in97.4%
distribute-frac-neg97.4%
sub-neg97.4%
neg-mul-197.4%
associate-*l/97.2%
neg-mul-197.2%
times-frac97.2%
distribute-lft-out--99.8%
*-commutative99.8%
associate-/r*99.8%
metadata-eval99.8%
Simplified99.8%
sub-neg99.8%
distribute-rgt-in97.2%
div-inv97.1%
*-commutative97.1%
associate-*l*97.1%
div-inv97.2%
*-commutative97.2%
metadata-eval97.2%
metadata-eval97.2%
times-frac97.4%
metadata-eval97.4%
neg-mul-197.4%
*-commutative97.4%
distribute-neg-frac97.4%
distribute-neg-frac97.4%
clear-num97.4%
div-inv97.4%
metadata-eval97.4%
metadata-eval97.4%
distribute-rgt-neg-in97.4%
times-frac97.4%
*-commutative97.4%
times-frac90.0%
Applied egg-rr99.9%
Taylor expanded in x around 0 81.2%
Taylor expanded in y around inf 78.8%
associate-*r/78.9%
*-commutative78.9%
associate-*r/79.0%
Simplified79.0%
associate-*r/78.9%
associate-/l*78.9%
div-inv79.0%
metadata-eval79.0%
Applied egg-rr79.0%
Final simplification68.2%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* 0.3333333333333333 (/ t (* z y))))
(t_2 (- x (* (/ y z) 0.3333333333333333))))
(if (<= y -2.3e-18)
t_2
(if (<= y 1.9e-205)
t_1
(if (<= y 3.1e-188) x (if (<= y 7.8e-122) t_1 t_2))))))
double code(double x, double y, double z, double t) {
double t_1 = 0.3333333333333333 * (t / (z * y));
double t_2 = x - ((y / z) * 0.3333333333333333);
double tmp;
if (y <= -2.3e-18) {
tmp = t_2;
} else if (y <= 1.9e-205) {
tmp = t_1;
} else if (y <= 3.1e-188) {
tmp = x;
} else if (y <= 7.8e-122) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = 0.3333333333333333d0 * (t / (z * y))
t_2 = x - ((y / z) * 0.3333333333333333d0)
if (y <= (-2.3d-18)) then
tmp = t_2
else if (y <= 1.9d-205) then
tmp = t_1
else if (y <= 3.1d-188) then
tmp = x
else if (y <= 7.8d-122) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = 0.3333333333333333 * (t / (z * y));
double t_2 = x - ((y / z) * 0.3333333333333333);
double tmp;
if (y <= -2.3e-18) {
tmp = t_2;
} else if (y <= 1.9e-205) {
tmp = t_1;
} else if (y <= 3.1e-188) {
tmp = x;
} else if (y <= 7.8e-122) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t): t_1 = 0.3333333333333333 * (t / (z * y)) t_2 = x - ((y / z) * 0.3333333333333333) tmp = 0 if y <= -2.3e-18: tmp = t_2 elif y <= 1.9e-205: tmp = t_1 elif y <= 3.1e-188: tmp = x elif y <= 7.8e-122: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t) t_1 = Float64(0.3333333333333333 * Float64(t / Float64(z * y))) t_2 = Float64(x - Float64(Float64(y / z) * 0.3333333333333333)) tmp = 0.0 if (y <= -2.3e-18) tmp = t_2; elseif (y <= 1.9e-205) tmp = t_1; elseif (y <= 3.1e-188) tmp = x; elseif (y <= 7.8e-122) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = 0.3333333333333333 * (t / (z * y)); t_2 = x - ((y / z) * 0.3333333333333333); tmp = 0.0; if (y <= -2.3e-18) tmp = t_2; elseif (y <= 1.9e-205) tmp = t_1; elseif (y <= 3.1e-188) tmp = x; elseif (y <= 7.8e-122) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(N[(y / z), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.3e-18], t$95$2, If[LessEqual[y, 1.9e-205], t$95$1, If[LessEqual[y, 3.1e-188], x, If[LessEqual[y, 7.8e-122], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
t_2 := x - \frac{y}{z} \cdot 0.3333333333333333\\
\mathbf{if}\;y \leq -2.3 \cdot 10^{-18}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{-205}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 3.1 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 7.8 \cdot 10^{-122}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -2.3000000000000001e-18 or 7.79999999999999979e-122 < y Initial program 96.9%
Taylor expanded in t around 0 86.4%
if -2.3000000000000001e-18 < y < 1.89999999999999996e-205 or 3.1000000000000002e-188 < y < 7.79999999999999979e-122Initial program 86.2%
associate-+l-86.2%
sub-neg86.2%
sub-neg86.2%
distribute-frac-neg86.2%
distribute-neg-in86.2%
distribute-frac-neg86.2%
sub-neg86.2%
neg-mul-186.2%
associate-*l/86.2%
neg-mul-186.2%
times-frac88.1%
distribute-lft-out--88.1%
*-commutative88.1%
associate-/r*88.1%
metadata-eval88.1%
Simplified88.1%
sub-neg88.1%
distribute-rgt-in88.1%
div-inv88.1%
*-commutative88.1%
associate-*l*88.1%
div-inv88.1%
*-commutative88.1%
metadata-eval88.1%
metadata-eval88.1%
times-frac88.1%
metadata-eval88.1%
neg-mul-188.1%
*-commutative88.1%
distribute-neg-frac88.1%
distribute-neg-frac88.1%
clear-num88.1%
div-inv88.1%
metadata-eval88.1%
metadata-eval88.1%
distribute-rgt-neg-in88.1%
times-frac86.2%
*-commutative86.2%
times-frac96.7%
Applied egg-rr88.2%
Taylor expanded in y around 0 66.3%
if 1.89999999999999996e-205 < y < 3.1000000000000002e-188Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
sub-neg100.0%
distribute-frac-neg100.0%
distribute-neg-in100.0%
distribute-frac-neg100.0%
sub-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
neg-mul-1100.0%
times-frac100.0%
distribute-lft-out--100.0%
*-commutative100.0%
associate-/r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification79.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* 0.3333333333333333 (/ t (* z y)))) (t_2 (- x (/ y (* z 3.0)))))
(if (<= y -2.8e-18)
t_2
(if (<= y 1.82e-205)
t_1
(if (<= y 3e-188) x (if (<= y 5e-122) t_1 t_2))))))
double code(double x, double y, double z, double t) {
double t_1 = 0.3333333333333333 * (t / (z * y));
double t_2 = x - (y / (z * 3.0));
double tmp;
if (y <= -2.8e-18) {
tmp = t_2;
} else if (y <= 1.82e-205) {
tmp = t_1;
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 5e-122) {
tmp = t_1;
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = 0.3333333333333333d0 * (t / (z * y))
t_2 = x - (y / (z * 3.0d0))
if (y <= (-2.8d-18)) then
tmp = t_2
else if (y <= 1.82d-205) then
tmp = t_1
else if (y <= 3d-188) then
tmp = x
else if (y <= 5d-122) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = 0.3333333333333333 * (t / (z * y));
double t_2 = x - (y / (z * 3.0));
double tmp;
if (y <= -2.8e-18) {
tmp = t_2;
} else if (y <= 1.82e-205) {
tmp = t_1;
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 5e-122) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t): t_1 = 0.3333333333333333 * (t / (z * y)) t_2 = x - (y / (z * 3.0)) tmp = 0 if y <= -2.8e-18: tmp = t_2 elif y <= 1.82e-205: tmp = t_1 elif y <= 3e-188: tmp = x elif y <= 5e-122: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t) t_1 = Float64(0.3333333333333333 * Float64(t / Float64(z * y))) t_2 = Float64(x - Float64(y / Float64(z * 3.0))) tmp = 0.0 if (y <= -2.8e-18) tmp = t_2; elseif (y <= 1.82e-205) tmp = t_1; elseif (y <= 3e-188) tmp = x; elseif (y <= 5e-122) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = 0.3333333333333333 * (t / (z * y)); t_2 = x - (y / (z * 3.0)); tmp = 0.0; if (y <= -2.8e-18) tmp = t_2; elseif (y <= 1.82e-205) tmp = t_1; elseif (y <= 3e-188) tmp = x; elseif (y <= 5e-122) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.8e-18], t$95$2, If[LessEqual[y, 1.82e-205], t$95$1, If[LessEqual[y, 3e-188], x, If[LessEqual[y, 5e-122], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
t_2 := x - \frac{y}{z \cdot 3}\\
\mathbf{if}\;y \leq -2.8 \cdot 10^{-18}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 1.82 \cdot 10^{-205}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 3 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 5 \cdot 10^{-122}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -2.80000000000000012e-18 or 4.9999999999999999e-122 < y Initial program 96.9%
Taylor expanded in t around 0 86.4%
*-commutative86.4%
metadata-eval86.4%
div-inv86.4%
associate-/r*86.5%
Applied egg-rr86.5%
if -2.80000000000000012e-18 < y < 1.81999999999999992e-205 or 3.00000000000000017e-188 < y < 4.9999999999999999e-122Initial program 86.2%
associate-+l-86.2%
sub-neg86.2%
sub-neg86.2%
distribute-frac-neg86.2%
distribute-neg-in86.2%
distribute-frac-neg86.2%
sub-neg86.2%
neg-mul-186.2%
associate-*l/86.2%
neg-mul-186.2%
times-frac88.1%
distribute-lft-out--88.1%
*-commutative88.1%
associate-/r*88.1%
metadata-eval88.1%
Simplified88.1%
sub-neg88.1%
distribute-rgt-in88.1%
div-inv88.1%
*-commutative88.1%
associate-*l*88.1%
div-inv88.1%
*-commutative88.1%
metadata-eval88.1%
metadata-eval88.1%
times-frac88.1%
metadata-eval88.1%
neg-mul-188.1%
*-commutative88.1%
distribute-neg-frac88.1%
distribute-neg-frac88.1%
clear-num88.1%
div-inv88.1%
metadata-eval88.1%
metadata-eval88.1%
distribute-rgt-neg-in88.1%
times-frac86.2%
*-commutative86.2%
times-frac96.7%
Applied egg-rr88.2%
Taylor expanded in y around 0 66.3%
if 1.81999999999999992e-205 < y < 3.00000000000000017e-188Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
sub-neg100.0%
distribute-frac-neg100.0%
distribute-neg-in100.0%
distribute-frac-neg100.0%
sub-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
neg-mul-1100.0%
times-frac100.0%
distribute-lft-out--100.0%
*-commutative100.0%
associate-/r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
Final simplification79.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* 0.3333333333333333 (/ t (* z y)))))
(if (<= y -3.4e-18)
(- x (/ (/ y 3.0) z))
(if (<= y 9.4e-206)
t_1
(if (<= y 9.6e-188)
x
(if (<= y 2.55e-127) t_1 (- x (/ y (* z 3.0)))))))))
double code(double x, double y, double z, double t) {
double t_1 = 0.3333333333333333 * (t / (z * y));
double tmp;
if (y <= -3.4e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 9.4e-206) {
tmp = t_1;
} else if (y <= 9.6e-188) {
tmp = x;
} else if (y <= 2.55e-127) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = 0.3333333333333333d0 * (t / (z * y))
if (y <= (-3.4d-18)) then
tmp = x - ((y / 3.0d0) / z)
else if (y <= 9.4d-206) then
tmp = t_1
else if (y <= 9.6d-188) then
tmp = x
else if (y <= 2.55d-127) then
tmp = t_1
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 t_1 = 0.3333333333333333 * (t / (z * y));
double tmp;
if (y <= -3.4e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 9.4e-206) {
tmp = t_1;
} else if (y <= 9.6e-188) {
tmp = x;
} else if (y <= 2.55e-127) {
tmp = t_1;
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): t_1 = 0.3333333333333333 * (t / (z * y)) tmp = 0 if y <= -3.4e-18: tmp = x - ((y / 3.0) / z) elif y <= 9.4e-206: tmp = t_1 elif y <= 9.6e-188: tmp = x elif y <= 2.55e-127: tmp = t_1 else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) t_1 = Float64(0.3333333333333333 * Float64(t / Float64(z * y))) tmp = 0.0 if (y <= -3.4e-18) tmp = Float64(x - Float64(Float64(y / 3.0) / z)); elseif (y <= 9.4e-206) tmp = t_1; elseif (y <= 9.6e-188) tmp = x; elseif (y <= 2.55e-127) tmp = t_1; else tmp = Float64(x - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = 0.3333333333333333 * (t / (z * y)); tmp = 0.0; if (y <= -3.4e-18) tmp = x - ((y / 3.0) / z); elseif (y <= 9.4e-206) tmp = t_1; elseif (y <= 9.6e-188) tmp = x; elseif (y <= 2.55e-127) tmp = t_1; else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.4e-18], N[(x - N[(N[(y / 3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.4e-206], t$95$1, If[LessEqual[y, 9.6e-188], x, If[LessEqual[y, 2.55e-127], t$95$1, N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{if}\;y \leq -3.4 \cdot 10^{-18}:\\
\;\;\;\;x - \frac{\frac{y}{3}}{z}\\
\mathbf{elif}\;y \leq 9.4 \cdot 10^{-206}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 9.6 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 2.55 \cdot 10^{-127}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -3.40000000000000001e-18Initial program 96.6%
Taylor expanded in t around 0 89.6%
associate-*r/89.6%
*-commutative89.6%
metadata-eval89.6%
div-inv89.7%
Applied egg-rr89.7%
if -3.40000000000000001e-18 < y < 9.3999999999999997e-206 or 9.6e-188 < y < 2.55000000000000009e-127Initial program 86.2%
associate-+l-86.2%
sub-neg86.2%
sub-neg86.2%
distribute-frac-neg86.2%
distribute-neg-in86.2%
distribute-frac-neg86.2%
sub-neg86.2%
neg-mul-186.2%
associate-*l/86.2%
neg-mul-186.2%
times-frac88.1%
distribute-lft-out--88.1%
*-commutative88.1%
associate-/r*88.1%
metadata-eval88.1%
Simplified88.1%
sub-neg88.1%
distribute-rgt-in88.1%
div-inv88.1%
*-commutative88.1%
associate-*l*88.1%
div-inv88.1%
*-commutative88.1%
metadata-eval88.1%
metadata-eval88.1%
times-frac88.1%
metadata-eval88.1%
neg-mul-188.1%
*-commutative88.1%
distribute-neg-frac88.1%
distribute-neg-frac88.1%
clear-num88.1%
div-inv88.1%
metadata-eval88.1%
metadata-eval88.1%
distribute-rgt-neg-in88.1%
times-frac86.2%
*-commutative86.2%
times-frac96.7%
Applied egg-rr88.2%
Taylor expanded in y around 0 66.3%
if 9.3999999999999997e-206 < y < 9.6e-188Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
sub-neg100.0%
distribute-frac-neg100.0%
distribute-neg-in100.0%
distribute-frac-neg100.0%
sub-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
neg-mul-1100.0%
times-frac100.0%
distribute-lft-out--100.0%
*-commutative100.0%
associate-/r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 2.55000000000000009e-127 < y Initial program 97.2%
Taylor expanded in t around 0 84.2%
*-commutative84.2%
metadata-eval84.2%
div-inv84.2%
associate-/r*84.4%
Applied egg-rr84.4%
Final simplification79.1%
(FPCore (x y z t)
:precision binary64
(if (<= y -4.8e-92)
(- x (/ (/ y 3.0) z))
(if (<= y 2.5e-211)
(/ (* (/ t y) 0.3333333333333333) z)
(if (<= y 3e-188)
(- x (* (/ y z) 0.3333333333333333))
(if (<= y 4.3e-128)
(* 0.3333333333333333 (/ t (* z y)))
(- x (/ y (* z 3.0))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -4.8e-92) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 2.5e-211) {
tmp = ((t / y) * 0.3333333333333333) / z;
} else if (y <= 3e-188) {
tmp = x - ((y / z) * 0.3333333333333333);
} else if (y <= 4.3e-128) {
tmp = 0.3333333333333333 * (t / (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.8d-92)) then
tmp = x - ((y / 3.0d0) / z)
else if (y <= 2.5d-211) then
tmp = ((t / y) * 0.3333333333333333d0) / z
else if (y <= 3d-188) then
tmp = x - ((y / z) * 0.3333333333333333d0)
else if (y <= 4.3d-128) then
tmp = 0.3333333333333333d0 * (t / (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.8e-92) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 2.5e-211) {
tmp = ((t / y) * 0.3333333333333333) / z;
} else if (y <= 3e-188) {
tmp = x - ((y / z) * 0.3333333333333333);
} else if (y <= 4.3e-128) {
tmp = 0.3333333333333333 * (t / (z * y));
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -4.8e-92: tmp = x - ((y / 3.0) / z) elif y <= 2.5e-211: tmp = ((t / y) * 0.3333333333333333) / z elif y <= 3e-188: tmp = x - ((y / z) * 0.3333333333333333) elif y <= 4.3e-128: tmp = 0.3333333333333333 * (t / (z * y)) else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -4.8e-92) tmp = Float64(x - Float64(Float64(y / 3.0) / z)); elseif (y <= 2.5e-211) tmp = Float64(Float64(Float64(t / y) * 0.3333333333333333) / z); elseif (y <= 3e-188) tmp = Float64(x - Float64(Float64(y / z) * 0.3333333333333333)); elseif (y <= 4.3e-128) tmp = Float64(0.3333333333333333 * Float64(t / Float64(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.8e-92) tmp = x - ((y / 3.0) / z); elseif (y <= 2.5e-211) tmp = ((t / y) * 0.3333333333333333) / z; elseif (y <= 3e-188) tmp = x - ((y / z) * 0.3333333333333333); elseif (y <= 4.3e-128) tmp = 0.3333333333333333 * (t / (z * y)); else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -4.8e-92], N[(x - N[(N[(y / 3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e-211], N[(N[(N[(t / y), $MachinePrecision] * 0.3333333333333333), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[y, 3e-188], N[(x - N[(N[(y / z), $MachinePrecision] * 0.3333333333333333), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.3e-128], N[(0.3333333333333333 * N[(t / N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.8 \cdot 10^{-92}:\\
\;\;\;\;x - \frac{\frac{y}{3}}{z}\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{-211}:\\
\;\;\;\;\frac{\frac{t}{y} \cdot 0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 3 \cdot 10^{-188}:\\
\;\;\;\;x - \frac{y}{z} \cdot 0.3333333333333333\\
\mathbf{elif}\;y \leq 4.3 \cdot 10^{-128}:\\
\;\;\;\;0.3333333333333333 \cdot \frac{t}{z \cdot y}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -4.8000000000000002e-92Initial program 97.2%
Taylor expanded in t around 0 81.6%
associate-*r/81.6%
*-commutative81.6%
metadata-eval81.6%
div-inv81.7%
Applied egg-rr81.7%
if -4.8000000000000002e-92 < y < 2.5000000000000001e-211Initial program 84.6%
associate-+l-84.6%
sub-neg84.6%
sub-neg84.6%
distribute-frac-neg84.6%
distribute-neg-in84.6%
distribute-frac-neg84.6%
sub-neg84.6%
neg-mul-184.6%
associate-*l/84.6%
neg-mul-184.6%
times-frac89.4%
distribute-lft-out--89.4%
*-commutative89.4%
associate-/r*89.4%
metadata-eval89.4%
Simplified89.4%
sub-neg89.4%
distribute-rgt-in89.4%
div-inv89.4%
*-commutative89.4%
associate-*l*89.4%
div-inv89.4%
*-commutative89.4%
metadata-eval89.4%
metadata-eval89.4%
times-frac89.4%
metadata-eval89.4%
neg-mul-189.4%
*-commutative89.4%
distribute-neg-frac89.4%
distribute-neg-frac89.4%
clear-num89.4%
div-inv89.4%
metadata-eval89.4%
metadata-eval89.4%
distribute-rgt-neg-in89.4%
times-frac84.6%
*-commutative84.6%
times-frac95.1%
Applied egg-rr89.5%
Taylor expanded in y around 0 67.2%
associate-*r/67.2%
*-commutative67.2%
associate-*r/66.6%
Simplified66.6%
associate-/r*66.6%
associate-*r/73.6%
Applied egg-rr73.6%
Taylor expanded in t around 0 73.7%
if 2.5000000000000001e-211 < y < 3.00000000000000017e-188Initial program 78.9%
Taylor expanded in t around 0 75.4%
if 3.00000000000000017e-188 < y < 4.29999999999999994e-128Initial program 88.0%
associate-+l-88.0%
sub-neg88.0%
sub-neg88.0%
distribute-frac-neg88.0%
distribute-neg-in88.0%
distribute-frac-neg88.0%
sub-neg88.0%
neg-mul-188.0%
associate-*l/88.0%
neg-mul-188.0%
times-frac82.1%
distribute-lft-out--82.1%
*-commutative82.1%
associate-/r*82.1%
metadata-eval82.1%
Simplified82.1%
sub-neg82.1%
distribute-rgt-in82.1%
div-inv82.1%
*-commutative82.1%
associate-*l*82.1%
div-inv82.1%
*-commutative82.1%
metadata-eval82.1%
metadata-eval82.1%
times-frac82.1%
metadata-eval82.1%
neg-mul-182.1%
*-commutative82.1%
distribute-neg-frac82.1%
distribute-neg-frac82.1%
clear-num82.0%
div-inv82.1%
metadata-eval82.1%
metadata-eval82.1%
distribute-rgt-neg-in82.1%
times-frac88.0%
*-commutative88.0%
times-frac99.6%
Applied egg-rr82.2%
Taylor expanded in y around 0 81.8%
if 4.29999999999999994e-128 < y Initial program 97.2%
Taylor expanded in t around 0 84.2%
*-commutative84.2%
metadata-eval84.2%
div-inv84.2%
associate-/r*84.4%
Applied egg-rr84.4%
Final simplification80.5%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (/ (* t (/ 0.3333333333333333 z)) y)))
(if (<= y -2.4e-18)
(- x (/ (/ y 3.0) z))
(if (<= y 1.9e-205)
t_1
(if (<= y 3e-188) x (if (<= y 1.2e-112) t_1 (- x (/ y (* z 3.0)))))))))
double code(double x, double y, double z, double t) {
double t_1 = (t * (0.3333333333333333 / z)) / y;
double tmp;
if (y <= -2.4e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 1.9e-205) {
tmp = t_1;
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 1.2e-112) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = (t * (0.3333333333333333d0 / z)) / y
if (y <= (-2.4d-18)) then
tmp = x - ((y / 3.0d0) / z)
else if (y <= 1.9d-205) then
tmp = t_1
else if (y <= 3d-188) then
tmp = x
else if (y <= 1.2d-112) then
tmp = t_1
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 t_1 = (t * (0.3333333333333333 / z)) / y;
double tmp;
if (y <= -2.4e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 1.9e-205) {
tmp = t_1;
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 1.2e-112) {
tmp = t_1;
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): t_1 = (t * (0.3333333333333333 / z)) / y tmp = 0 if y <= -2.4e-18: tmp = x - ((y / 3.0) / z) elif y <= 1.9e-205: tmp = t_1 elif y <= 3e-188: tmp = x elif y <= 1.2e-112: tmp = t_1 else: tmp = x - (y / (z * 3.0)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(t * Float64(0.3333333333333333 / z)) / y) tmp = 0.0 if (y <= -2.4e-18) tmp = Float64(x - Float64(Float64(y / 3.0) / z)); elseif (y <= 1.9e-205) tmp = t_1; elseif (y <= 3e-188) tmp = x; elseif (y <= 1.2e-112) tmp = t_1; else tmp = Float64(x - Float64(y / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (t * (0.3333333333333333 / z)) / y; tmp = 0.0; if (y <= -2.4e-18) tmp = x - ((y / 3.0) / z); elseif (y <= 1.9e-205) tmp = t_1; elseif (y <= 3e-188) tmp = x; elseif (y <= 1.2e-112) tmp = t_1; else tmp = x - (y / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(t * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -2.4e-18], N[(x - N[(N[(y / 3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.9e-205], t$95$1, If[LessEqual[y, 3e-188], x, If[LessEqual[y, 1.2e-112], t$95$1, N[(x - N[(y / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\mathbf{if}\;y \leq -2.4 \cdot 10^{-18}:\\
\;\;\;\;x - \frac{\frac{y}{3}}{z}\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{-205}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 3 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{-112}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -2.39999999999999994e-18Initial program 96.6%
Taylor expanded in t around 0 89.6%
associate-*r/89.6%
*-commutative89.6%
metadata-eval89.6%
div-inv89.7%
Applied egg-rr89.7%
if -2.39999999999999994e-18 < y < 1.89999999999999996e-205 or 3.00000000000000017e-188 < y < 1.2e-112Initial program 86.0%
associate-+l-86.0%
sub-neg86.0%
sub-neg86.0%
distribute-frac-neg86.0%
distribute-neg-in86.0%
distribute-frac-neg86.0%
sub-neg86.0%
neg-mul-186.0%
associate-*l/86.0%
neg-mul-186.0%
times-frac88.4%
distribute-lft-out--88.4%
*-commutative88.4%
associate-/r*88.4%
metadata-eval88.4%
Simplified88.4%
sub-neg88.4%
distribute-rgt-in88.4%
div-inv88.4%
*-commutative88.4%
associate-*l*88.4%
div-inv88.4%
*-commutative88.4%
metadata-eval88.4%
metadata-eval88.4%
times-frac88.4%
metadata-eval88.4%
neg-mul-188.4%
*-commutative88.4%
distribute-neg-frac88.4%
distribute-neg-frac88.4%
clear-num88.3%
div-inv88.4%
metadata-eval88.4%
metadata-eval88.4%
distribute-rgt-neg-in88.4%
times-frac86.0%
*-commutative86.0%
times-frac96.8%
Applied egg-rr88.5%
Taylor expanded in y around 0 65.5%
associate-*r/65.5%
*-commutative65.5%
associate-*r/64.4%
Simplified64.4%
associate-*r/65.5%
associate-/l/73.9%
associate-*r/73.9%
Applied egg-rr73.9%
if 1.89999999999999996e-205 < y < 3.00000000000000017e-188Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
sub-neg100.0%
distribute-frac-neg100.0%
distribute-neg-in100.0%
distribute-frac-neg100.0%
sub-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
neg-mul-1100.0%
times-frac100.0%
distribute-lft-out--100.0%
*-commutative100.0%
associate-/r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 1.2e-112 < y Initial program 97.6%
Taylor expanded in t around 0 85.0%
*-commutative85.0%
metadata-eval85.0%
div-inv85.0%
associate-/r*85.1%
Applied egg-rr85.1%
Final simplification82.2%
(FPCore (x y z t)
:precision binary64
(if (<= y -3.4e-18)
(- x (/ (/ y 3.0) z))
(if (<= y 1.9e-205)
(/ (/ t z) (* 3.0 y))
(if (<= y 3e-188)
x
(if (<= y 1.02e-112)
(/ (* t (/ 0.3333333333333333 z)) y)
(- x (/ y (* z 3.0))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -3.4e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 1.9e-205) {
tmp = (t / z) / (3.0 * y);
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 1.02e-112) {
tmp = (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 <= (-3.4d-18)) then
tmp = x - ((y / 3.0d0) / z)
else if (y <= 1.9d-205) then
tmp = (t / z) / (3.0d0 * y)
else if (y <= 3d-188) then
tmp = x
else if (y <= 1.02d-112) then
tmp = (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 <= -3.4e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 1.9e-205) {
tmp = (t / z) / (3.0 * y);
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 1.02e-112) {
tmp = (t * (0.3333333333333333 / z)) / y;
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -3.4e-18: tmp = x - ((y / 3.0) / z) elif y <= 1.9e-205: tmp = (t / z) / (3.0 * y) elif y <= 3e-188: tmp = x elif y <= 1.02e-112: tmp = (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 <= -3.4e-18) tmp = Float64(x - Float64(Float64(y / 3.0) / z)); elseif (y <= 1.9e-205) tmp = Float64(Float64(t / z) / Float64(3.0 * y)); elseif (y <= 3e-188) tmp = x; elseif (y <= 1.02e-112) tmp = 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 <= -3.4e-18) tmp = x - ((y / 3.0) / z); elseif (y <= 1.9e-205) tmp = (t / z) / (3.0 * y); elseif (y <= 3e-188) tmp = x; elseif (y <= 1.02e-112) tmp = (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, -3.4e-18], N[(x - N[(N[(y / 3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.9e-205], N[(N[(t / z), $MachinePrecision] / N[(3.0 * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3e-188], x, If[LessEqual[y, 1.02e-112], N[(N[(t * N[(0.3333333333333333 / z), $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.4 \cdot 10^{-18}:\\
\;\;\;\;x - \frac{\frac{y}{3}}{z}\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{-205}:\\
\;\;\;\;\frac{\frac{t}{z}}{3 \cdot y}\\
\mathbf{elif}\;y \leq 3 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.02 \cdot 10^{-112}:\\
\;\;\;\;\frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -3.40000000000000001e-18Initial program 96.6%
Taylor expanded in t around 0 89.6%
associate-*r/89.6%
*-commutative89.6%
metadata-eval89.6%
div-inv89.7%
Applied egg-rr89.7%
if -3.40000000000000001e-18 < y < 1.89999999999999996e-205Initial program 85.9%
associate-+l-85.9%
sub-neg85.9%
sub-neg85.9%
distribute-frac-neg85.9%
distribute-neg-in85.9%
distribute-frac-neg85.9%
sub-neg85.9%
neg-mul-185.9%
associate-*l/85.9%
neg-mul-185.9%
times-frac89.3%
distribute-lft-out--89.3%
*-commutative89.3%
associate-/r*89.3%
metadata-eval89.3%
Simplified89.3%
sub-neg89.3%
distribute-rgt-in89.3%
div-inv89.3%
*-commutative89.3%
associate-*l*89.3%
div-inv89.3%
*-commutative89.3%
metadata-eval89.3%
metadata-eval89.3%
times-frac89.3%
metadata-eval89.3%
neg-mul-189.3%
*-commutative89.3%
distribute-neg-frac89.3%
distribute-neg-frac89.3%
clear-num89.3%
div-inv89.3%
metadata-eval89.3%
metadata-eval89.3%
distribute-rgt-neg-in89.3%
times-frac85.9%
*-commutative85.9%
times-frac96.1%
Applied egg-rr89.4%
Taylor expanded in y around 0 63.3%
associate-*r/63.3%
*-commutative63.3%
associate-*r/62.4%
Simplified62.4%
associate-*r/63.3%
*-commutative63.3%
times-frac70.5%
clear-num70.5%
un-div-inv70.5%
div-inv70.5%
metadata-eval70.5%
Applied egg-rr70.5%
if 1.89999999999999996e-205 < y < 3.00000000000000017e-188Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
sub-neg100.0%
distribute-frac-neg100.0%
distribute-neg-in100.0%
distribute-frac-neg100.0%
sub-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
neg-mul-1100.0%
times-frac100.0%
distribute-lft-out--100.0%
*-commutative100.0%
associate-/r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 3.00000000000000017e-188 < y < 1.01999999999999996e-112Initial program 86.7%
associate-+l-86.7%
sub-neg86.7%
sub-neg86.7%
distribute-frac-neg86.7%
distribute-neg-in86.7%
distribute-frac-neg86.7%
sub-neg86.7%
neg-mul-186.7%
associate-*l/86.7%
neg-mul-186.7%
times-frac84.0%
distribute-lft-out--84.0%
*-commutative84.0%
associate-/r*84.0%
metadata-eval84.0%
Simplified84.0%
sub-neg84.0%
distribute-rgt-in84.0%
div-inv84.0%
*-commutative84.0%
associate-*l*84.0%
div-inv84.0%
*-commutative84.0%
metadata-eval84.0%
metadata-eval84.0%
times-frac84.0%
metadata-eval84.0%
neg-mul-184.0%
*-commutative84.0%
distribute-neg-frac84.0%
distribute-neg-frac84.0%
clear-num83.9%
div-inv84.0%
metadata-eval84.0%
metadata-eval84.0%
distribute-rgt-neg-in84.0%
times-frac86.7%
*-commutative86.7%
times-frac99.6%
Applied egg-rr84.1%
Taylor expanded in y around 0 75.5%
associate-*r/75.5%
*-commutative75.5%
associate-*r/73.5%
Simplified73.5%
associate-*r/75.5%
associate-/l/89.1%
associate-*r/89.2%
Applied egg-rr89.2%
if 1.01999999999999996e-112 < y Initial program 97.6%
Taylor expanded in t around 0 85.0%
*-commutative85.0%
metadata-eval85.0%
div-inv85.0%
associate-/r*85.1%
Applied egg-rr85.1%
Final simplification82.2%
(FPCore (x y z t)
:precision binary64
(if (<= y -2.3e-18)
(- x (/ (/ y 3.0) z))
(if (<= y 1.9e-205)
(/ (* -0.3333333333333333 (/ t z)) (- y))
(if (<= y 3e-188)
x
(if (<= y 1.2e-112)
(/ (* t (/ 0.3333333333333333 z)) y)
(- x (/ y (* z 3.0))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -2.3e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 1.9e-205) {
tmp = (-0.3333333333333333 * (t / z)) / -y;
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 1.2e-112) {
tmp = (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 <= (-2.3d-18)) then
tmp = x - ((y / 3.0d0) / z)
else if (y <= 1.9d-205) then
tmp = ((-0.3333333333333333d0) * (t / z)) / -y
else if (y <= 3d-188) then
tmp = x
else if (y <= 1.2d-112) then
tmp = (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 <= -2.3e-18) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 1.9e-205) {
tmp = (-0.3333333333333333 * (t / z)) / -y;
} else if (y <= 3e-188) {
tmp = x;
} else if (y <= 1.2e-112) {
tmp = (t * (0.3333333333333333 / z)) / y;
} else {
tmp = x - (y / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -2.3e-18: tmp = x - ((y / 3.0) / z) elif y <= 1.9e-205: tmp = (-0.3333333333333333 * (t / z)) / -y elif y <= 3e-188: tmp = x elif y <= 1.2e-112: tmp = (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 <= -2.3e-18) tmp = Float64(x - Float64(Float64(y / 3.0) / z)); elseif (y <= 1.9e-205) tmp = Float64(Float64(-0.3333333333333333 * Float64(t / z)) / Float64(-y)); elseif (y <= 3e-188) tmp = x; elseif (y <= 1.2e-112) tmp = 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 <= -2.3e-18) tmp = x - ((y / 3.0) / z); elseif (y <= 1.9e-205) tmp = (-0.3333333333333333 * (t / z)) / -y; elseif (y <= 3e-188) tmp = x; elseif (y <= 1.2e-112) tmp = (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, -2.3e-18], N[(x - N[(N[(y / 3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.9e-205], N[(N[(-0.3333333333333333 * N[(t / z), $MachinePrecision]), $MachinePrecision] / (-y)), $MachinePrecision], If[LessEqual[y, 3e-188], x, If[LessEqual[y, 1.2e-112], N[(N[(t * N[(0.3333333333333333 / z), $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 -2.3 \cdot 10^{-18}:\\
\;\;\;\;x - \frac{\frac{y}{3}}{z}\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{-205}:\\
\;\;\;\;\frac{-0.3333333333333333 \cdot \frac{t}{z}}{-y}\\
\mathbf{elif}\;y \leq 3 \cdot 10^{-188}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{-112}:\\
\;\;\;\;\frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -2.3000000000000001e-18Initial program 96.6%
Taylor expanded in t around 0 89.6%
associate-*r/89.6%
*-commutative89.6%
metadata-eval89.6%
div-inv89.7%
Applied egg-rr89.7%
if -2.3000000000000001e-18 < y < 1.89999999999999996e-205Initial program 85.9%
associate-+l-85.9%
sub-neg85.9%
sub-neg85.9%
distribute-frac-neg85.9%
distribute-neg-in85.9%
distribute-frac-neg85.9%
sub-neg85.9%
neg-mul-185.9%
associate-*l/85.9%
neg-mul-185.9%
times-frac89.3%
distribute-lft-out--89.3%
*-commutative89.3%
associate-/r*89.3%
metadata-eval89.3%
Simplified89.3%
sub-neg89.3%
distribute-rgt-in89.3%
div-inv89.3%
*-commutative89.3%
associate-*l*89.3%
div-inv89.3%
*-commutative89.3%
metadata-eval89.3%
metadata-eval89.3%
times-frac89.3%
metadata-eval89.3%
neg-mul-189.3%
*-commutative89.3%
distribute-neg-frac89.3%
distribute-neg-frac89.3%
clear-num89.3%
div-inv89.3%
metadata-eval89.3%
metadata-eval89.3%
distribute-rgt-neg-in89.3%
times-frac85.9%
*-commutative85.9%
times-frac96.1%
Applied egg-rr89.4%
Taylor expanded in y around 0 63.3%
associate-*r/63.3%
*-commutative63.3%
associate-*r/62.4%
Simplified62.4%
associate-*r/63.3%
associate-/l/70.5%
associate-*r/70.5%
frac-2neg70.5%
neg-mul-170.5%
metadata-eval70.5%
*-commutative70.5%
div-inv70.5%
associate-*l*70.5%
*-commutative70.5%
div-inv70.6%
associate-*r*70.6%
metadata-eval70.6%
metadata-eval70.6%
Applied egg-rr70.6%
if 1.89999999999999996e-205 < y < 3.00000000000000017e-188Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
sub-neg100.0%
distribute-frac-neg100.0%
distribute-neg-in100.0%
distribute-frac-neg100.0%
sub-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
neg-mul-1100.0%
times-frac100.0%
distribute-lft-out--100.0%
*-commutative100.0%
associate-/r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in x around inf 100.0%
if 3.00000000000000017e-188 < y < 1.2e-112Initial program 86.7%
associate-+l-86.7%
sub-neg86.7%
sub-neg86.7%
distribute-frac-neg86.7%
distribute-neg-in86.7%
distribute-frac-neg86.7%
sub-neg86.7%
neg-mul-186.7%
associate-*l/86.7%
neg-mul-186.7%
times-frac84.0%
distribute-lft-out--84.0%
*-commutative84.0%
associate-/r*84.0%
metadata-eval84.0%
Simplified84.0%
sub-neg84.0%
distribute-rgt-in84.0%
div-inv84.0%
*-commutative84.0%
associate-*l*84.0%
div-inv84.0%
*-commutative84.0%
metadata-eval84.0%
metadata-eval84.0%
times-frac84.0%
metadata-eval84.0%
neg-mul-184.0%
*-commutative84.0%
distribute-neg-frac84.0%
distribute-neg-frac84.0%
clear-num83.9%
div-inv84.0%
metadata-eval84.0%
metadata-eval84.0%
distribute-rgt-neg-in84.0%
times-frac86.7%
*-commutative86.7%
times-frac99.6%
Applied egg-rr84.1%
Taylor expanded in y around 0 75.5%
associate-*r/75.5%
*-commutative75.5%
associate-*r/73.5%
Simplified73.5%
associate-*r/75.5%
associate-/l/89.1%
associate-*r/89.2%
Applied egg-rr89.2%
if 1.2e-112 < y Initial program 97.6%
Taylor expanded in t around 0 85.0%
*-commutative85.0%
metadata-eval85.0%
div-inv85.0%
associate-/r*85.1%
Applied egg-rr85.1%
Final simplification82.2%
(FPCore (x y z t) :precision binary64 (if (or (<= y -4.3e-194) (not (<= y 2.2e-64))) (+ x (* (- y (/ t y)) (/ -0.3333333333333333 z))) (+ x (/ (* t (/ 0.3333333333333333 z)) y))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -4.3e-194) || !(y <= 2.2e-64)) {
tmp = x + ((y - (t / y)) * (-0.3333333333333333 / z));
} else {
tmp = x + ((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) :: tmp
if ((y <= (-4.3d-194)) .or. (.not. (y <= 2.2d-64))) then
tmp = x + ((y - (t / y)) * ((-0.3333333333333333d0) / z))
else
tmp = x + ((t * (0.3333333333333333d0 / z)) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -4.3e-194) || !(y <= 2.2e-64)) {
tmp = x + ((y - (t / y)) * (-0.3333333333333333 / z));
} else {
tmp = x + ((t * (0.3333333333333333 / z)) / y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -4.3e-194) or not (y <= 2.2e-64): tmp = x + ((y - (t / y)) * (-0.3333333333333333 / z)) else: tmp = x + ((t * (0.3333333333333333 / z)) / y) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -4.3e-194) || !(y <= 2.2e-64)) tmp = Float64(x + Float64(Float64(y - Float64(t / y)) * Float64(-0.3333333333333333 / z))); else tmp = Float64(x + Float64(Float64(t * Float64(0.3333333333333333 / z)) / y)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -4.3e-194) || ~((y <= 2.2e-64))) tmp = x + ((y - (t / y)) * (-0.3333333333333333 / z)); else tmp = x + ((t * (0.3333333333333333 / z)) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -4.3e-194], N[Not[LessEqual[y, 2.2e-64]], $MachinePrecision]], N[(x + N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t * N[(0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.3 \cdot 10^{-194} \lor \neg \left(y \leq 2.2 \cdot 10^{-64}\right):\\
\;\;\;\;x + \left(y - \frac{t}{y}\right) \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\end{array}
\end{array}
if y < -4.30000000000000006e-194 or 2.2e-64 < y Initial program 96.4%
associate-+l-96.4%
sub-neg96.4%
sub-neg96.4%
distribute-frac-neg96.4%
distribute-neg-in96.4%
distribute-frac-neg96.4%
sub-neg96.4%
neg-mul-196.4%
associate-*l/96.4%
neg-mul-196.4%
times-frac96.9%
distribute-lft-out--98.6%
*-commutative98.6%
associate-/r*98.6%
metadata-eval98.6%
Simplified98.6%
if -4.30000000000000006e-194 < y < 2.2e-64Initial program 85.8%
associate-+l-85.8%
sub-neg85.8%
sub-neg85.8%
distribute-frac-neg85.8%
distribute-neg-in85.8%
distribute-frac-neg85.8%
sub-neg85.8%
neg-mul-185.8%
associate-*l/85.8%
neg-mul-185.8%
times-frac86.4%
distribute-lft-out--86.4%
*-commutative86.4%
associate-/r*86.4%
metadata-eval86.4%
Simplified86.4%
Taylor expanded in y around 0 84.4%
*-commutative84.4%
associate-*l/84.4%
times-frac85.2%
Simplified85.2%
associate-*l/96.4%
Applied egg-rr96.4%
Final simplification97.9%
(FPCore (x y z t) :precision binary64 (if (or (<= y -5.6e-211) (not (<= y 2.1e-62))) (- x (/ (- y (/ t y)) (* z 3.0))) (+ x (/ (/ 1.0 y) (/ (* z 3.0) t)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -5.6e-211) || !(y <= 2.1e-62)) {
tmp = x - ((y - (t / y)) / (z * 3.0));
} else {
tmp = x + ((1.0 / y) / ((z * 3.0) / t));
}
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 <= (-5.6d-211)) .or. (.not. (y <= 2.1d-62))) then
tmp = x - ((y - (t / y)) / (z * 3.0d0))
else
tmp = x + ((1.0d0 / y) / ((z * 3.0d0) / t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((y <= -5.6e-211) || !(y <= 2.1e-62)) {
tmp = x - ((y - (t / y)) / (z * 3.0));
} else {
tmp = x + ((1.0 / y) / ((z * 3.0) / t));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (y <= -5.6e-211) or not (y <= 2.1e-62): tmp = x - ((y - (t / y)) / (z * 3.0)) else: tmp = x + ((1.0 / y) / ((z * 3.0) / t)) return tmp
function code(x, y, z, t) tmp = 0.0 if ((y <= -5.6e-211) || !(y <= 2.1e-62)) tmp = Float64(x - Float64(Float64(y - Float64(t / y)) / Float64(z * 3.0))); else tmp = Float64(x + Float64(Float64(1.0 / y) / Float64(Float64(z * 3.0) / t))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((y <= -5.6e-211) || ~((y <= 2.1e-62))) tmp = x - ((y - (t / y)) / (z * 3.0)); else tmp = x + ((1.0 / y) / ((z * 3.0) / t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[y, -5.6e-211], N[Not[LessEqual[y, 2.1e-62]], $MachinePrecision]], N[(x - N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(1.0 / y), $MachinePrecision] / N[(N[(z * 3.0), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.6 \cdot 10^{-211} \lor \neg \left(y \leq 2.1 \cdot 10^{-62}\right):\\
\;\;\;\;x - \frac{y - \frac{t}{y}}{z \cdot 3}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{\frac{1}{y}}{\frac{z \cdot 3}{t}}\\
\end{array}
\end{array}
if y < -5.5999999999999996e-211 or 2.0999999999999999e-62 < y Initial program 95.6%
associate-+l-95.6%
sub-neg95.6%
sub-neg95.6%
distribute-frac-neg95.6%
distribute-neg-in95.6%
distribute-frac-neg95.6%
sub-neg95.6%
neg-mul-195.6%
associate-*l/95.5%
neg-mul-195.5%
times-frac97.0%
distribute-lft-out--98.7%
*-commutative98.7%
associate-/r*98.7%
metadata-eval98.7%
Simplified98.7%
sub-neg98.7%
distribute-rgt-in97.0%
div-inv96.9%
*-commutative96.9%
associate-*l*96.9%
div-inv97.0%
*-commutative97.0%
metadata-eval97.0%
metadata-eval97.0%
times-frac97.1%
metadata-eval97.1%
neg-mul-197.1%
*-commutative97.1%
distribute-neg-frac97.1%
distribute-neg-frac97.1%
clear-num97.1%
div-inv97.1%
metadata-eval97.1%
metadata-eval97.1%
distribute-rgt-neg-in97.1%
times-frac95.6%
*-commutative95.6%
times-frac94.3%
Applied egg-rr98.8%
if -5.5999999999999996e-211 < y < 2.0999999999999999e-62Initial program 87.0%
associate-+l-87.0%
sub-neg87.0%
sub-neg87.0%
distribute-frac-neg87.0%
distribute-neg-in87.0%
distribute-frac-neg87.0%
sub-neg87.0%
neg-mul-187.0%
associate-*l/87.0%
neg-mul-187.0%
times-frac85.4%
distribute-lft-out--85.4%
*-commutative85.4%
associate-/r*85.3%
metadata-eval85.3%
Simplified85.3%
Taylor expanded in y around 0 85.5%
*-commutative85.5%
associate-*l/85.5%
times-frac84.1%
Simplified84.1%
associate-*r/84.1%
associate-/l*84.1%
div-inv84.1%
*-commutative84.1%
div-inv84.2%
metadata-eval84.2%
associate-/l*96.2%
Applied egg-rr96.2%
Final simplification98.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- y (/ t y))))
(if (<= y -5e-167)
(+ x (/ (* t_1 -0.3333333333333333) z))
(if (<= y 3.8e-64)
(+ x (/ (* t (/ 0.3333333333333333 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 <= -5e-167) {
tmp = x + ((t_1 * -0.3333333333333333) / z);
} else if (y <= 3.8e-64) {
tmp = x + ((t * (0.3333333333333333 / 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 <= (-5d-167)) then
tmp = x + ((t_1 * (-0.3333333333333333d0)) / z)
else if (y <= 3.8d-64) then
tmp = x + ((t * (0.3333333333333333d0 / 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 <= -5e-167) {
tmp = x + ((t_1 * -0.3333333333333333) / z);
} else if (y <= 3.8e-64) {
tmp = x + ((t * (0.3333333333333333 / 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 <= -5e-167: tmp = x + ((t_1 * -0.3333333333333333) / z) elif y <= 3.8e-64: tmp = x + ((t * (0.3333333333333333 / 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 <= -5e-167) tmp = Float64(x + Float64(Float64(t_1 * -0.3333333333333333) / z)); elseif (y <= 3.8e-64) tmp = Float64(x + Float64(Float64(t * Float64(0.3333333333333333 / 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 <= -5e-167) tmp = x + ((t_1 * -0.3333333333333333) / z); elseif (y <= 3.8e-64) tmp = x + ((t * (0.3333333333333333 / 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, -5e-167], N[(x + N[(N[(t$95$1 * -0.3333333333333333), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.8e-64], N[(x + N[(N[(t * N[(0.3333333333333333 / 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 -5 \cdot 10^{-167}:\\
\;\;\;\;x + \frac{t_1 \cdot -0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{-64}:\\
\;\;\;\;x + \frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;x + t_1 \cdot \frac{-0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -5.0000000000000002e-167Initial program 96.6%
associate-+l-96.6%
sub-neg96.6%
sub-neg96.6%
distribute-frac-neg96.6%
distribute-neg-in96.6%
distribute-frac-neg96.6%
sub-neg96.6%
neg-mul-196.6%
associate-*l/96.6%
neg-mul-196.6%
times-frac95.5%
distribute-lft-out--97.6%
*-commutative97.6%
associate-/r*97.6%
metadata-eval97.6%
Simplified97.6%
associate-*l/97.7%
Applied egg-rr97.7%
if -5.0000000000000002e-167 < y < 3.8000000000000002e-64Initial program 85.2%
associate-+l-85.2%
sub-neg85.2%
sub-neg85.2%
distribute-frac-neg85.2%
distribute-neg-in85.2%
distribute-frac-neg85.2%
sub-neg85.2%
neg-mul-185.2%
associate-*l/85.2%
neg-mul-185.2%
times-frac86.9%
distribute-lft-out--86.9%
*-commutative86.9%
associate-/r*86.8%
metadata-eval86.8%
Simplified86.8%
Taylor expanded in y around 0 83.9%
*-commutative83.9%
associate-*l/83.8%
times-frac85.7%
Simplified85.7%
associate-*l/96.5%
Applied egg-rr96.5%
if 3.8000000000000002e-64 < y Initial program 97.3%
associate-+l-97.3%
sub-neg97.3%
sub-neg97.3%
distribute-frac-neg97.3%
distribute-neg-in97.3%
distribute-frac-neg97.3%
sub-neg97.3%
neg-mul-197.3%
associate-*l/97.2%
neg-mul-197.2%
times-frac98.5%
distribute-lft-out--99.8%
*-commutative99.8%
associate-/r*99.8%
metadata-eval99.8%
Simplified99.8%
Final simplification97.9%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- y (/ t y))))
(if (<= y -2.5e-202)
(+ x (/ (* t_1 -0.3333333333333333) z))
(if (<= y 2.95e-64)
(+ x (/ (/ 1.0 y) (/ (* z 3.0) t)))
(+ 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 <= -2.5e-202) {
tmp = x + ((t_1 * -0.3333333333333333) / z);
} else if (y <= 2.95e-64) {
tmp = x + ((1.0 / y) / ((z * 3.0) / t));
} 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 <= (-2.5d-202)) then
tmp = x + ((t_1 * (-0.3333333333333333d0)) / z)
else if (y <= 2.95d-64) then
tmp = x + ((1.0d0 / y) / ((z * 3.0d0) / t))
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 <= -2.5e-202) {
tmp = x + ((t_1 * -0.3333333333333333) / z);
} else if (y <= 2.95e-64) {
tmp = x + ((1.0 / y) / ((z * 3.0) / t));
} 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 <= -2.5e-202: tmp = x + ((t_1 * -0.3333333333333333) / z) elif y <= 2.95e-64: tmp = x + ((1.0 / y) / ((z * 3.0) / t)) 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 <= -2.5e-202) tmp = Float64(x + Float64(Float64(t_1 * -0.3333333333333333) / z)); elseif (y <= 2.95e-64) tmp = Float64(x + Float64(Float64(1.0 / y) / Float64(Float64(z * 3.0) / t))); 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 <= -2.5e-202) tmp = x + ((t_1 * -0.3333333333333333) / z); elseif (y <= 2.95e-64) tmp = x + ((1.0 / y) / ((z * 3.0) / t)); 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, -2.5e-202], N[(x + N[(N[(t$95$1 * -0.3333333333333333), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.95e-64], N[(x + N[(N[(1.0 / y), $MachinePrecision] / N[(N[(z * 3.0), $MachinePrecision] / t), $MachinePrecision]), $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 -2.5 \cdot 10^{-202}:\\
\;\;\;\;x + \frac{t_1 \cdot -0.3333333333333333}{z}\\
\mathbf{elif}\;y \leq 2.95 \cdot 10^{-64}:\\
\;\;\;\;x + \frac{\frac{1}{y}}{\frac{z \cdot 3}{t}}\\
\mathbf{else}:\\
\;\;\;\;x + t_1 \cdot \frac{-0.3333333333333333}{z}\\
\end{array}
\end{array}
if y < -2.49999999999999986e-202Initial program 94.9%
associate-+l-94.9%
sub-neg94.9%
sub-neg94.9%
distribute-frac-neg94.9%
distribute-neg-in94.9%
distribute-frac-neg94.9%
sub-neg94.9%
neg-mul-194.9%
associate-*l/94.9%
neg-mul-194.9%
times-frac95.7%
distribute-lft-out--97.8%
*-commutative97.8%
associate-/r*97.8%
metadata-eval97.8%
Simplified97.8%
associate-*l/97.9%
Applied egg-rr97.9%
if -2.49999999999999986e-202 < y < 2.94999999999999997e-64Initial program 86.3%
associate-+l-86.3%
sub-neg86.3%
sub-neg86.3%
distribute-frac-neg86.3%
distribute-neg-in86.3%
distribute-frac-neg86.3%
sub-neg86.3%
neg-mul-186.3%
associate-*l/86.3%
neg-mul-186.3%
times-frac85.7%
distribute-lft-out--85.7%
*-commutative85.7%
associate-/r*85.7%
metadata-eval85.7%
Simplified85.7%
Taylor expanded in y around 0 84.8%
*-commutative84.8%
associate-*l/84.8%
times-frac84.5%
Simplified84.5%
associate-*r/84.5%
associate-/l*84.5%
div-inv84.5%
*-commutative84.5%
div-inv84.6%
metadata-eval84.6%
associate-/l*96.2%
Applied egg-rr96.2%
if 2.94999999999999997e-64 < y Initial program 97.3%
associate-+l-97.3%
sub-neg97.3%
sub-neg97.3%
distribute-frac-neg97.3%
distribute-neg-in97.3%
distribute-frac-neg97.3%
sub-neg97.3%
neg-mul-197.3%
associate-*l/97.2%
neg-mul-197.2%
times-frac98.5%
distribute-lft-out--99.8%
*-commutative99.8%
associate-/r*99.8%
metadata-eval99.8%
Simplified99.8%
Final simplification97.9%
(FPCore (x y z t)
:precision binary64
(if (<= y -2.3e-156)
(+ x (* (/ (- (/ t y) y) -3.0) (/ -1.0 z)))
(if (<= y 1e-63)
(+ x (/ (/ 1.0 y) (/ (* z 3.0) t)))
(- x (/ (- y (/ t y)) (* z 3.0))))))
double code(double x, double y, double z, double t) {
double tmp;
if (y <= -2.3e-156) {
tmp = x + ((((t / y) - y) / -3.0) * (-1.0 / z));
} else if (y <= 1e-63) {
tmp = x + ((1.0 / y) / ((z * 3.0) / t));
} else {
tmp = x - ((y - (t / 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.3d-156)) then
tmp = x + ((((t / y) - y) / (-3.0d0)) * ((-1.0d0) / z))
else if (y <= 1d-63) then
tmp = x + ((1.0d0 / y) / ((z * 3.0d0) / t))
else
tmp = x - ((y - (t / 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.3e-156) {
tmp = x + ((((t / y) - y) / -3.0) * (-1.0 / z));
} else if (y <= 1e-63) {
tmp = x + ((1.0 / y) / ((z * 3.0) / t));
} else {
tmp = x - ((y - (t / y)) / (z * 3.0));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if y <= -2.3e-156: tmp = x + ((((t / y) - y) / -3.0) * (-1.0 / z)) elif y <= 1e-63: tmp = x + ((1.0 / y) / ((z * 3.0) / t)) else: tmp = x - ((y - (t / y)) / (z * 3.0)) return tmp
function code(x, y, z, t) tmp = 0.0 if (y <= -2.3e-156) tmp = Float64(x + Float64(Float64(Float64(Float64(t / y) - y) / -3.0) * Float64(-1.0 / z))); elseif (y <= 1e-63) tmp = Float64(x + Float64(Float64(1.0 / y) / Float64(Float64(z * 3.0) / t))); else tmp = Float64(x - Float64(Float64(y - Float64(t / y)) / Float64(z * 3.0))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (y <= -2.3e-156) tmp = x + ((((t / y) - y) / -3.0) * (-1.0 / z)); elseif (y <= 1e-63) tmp = x + ((1.0 / y) / ((z * 3.0) / t)); else tmp = x - ((y - (t / y)) / (z * 3.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[y, -2.3e-156], N[(x + N[(N[(N[(N[(t / y), $MachinePrecision] - y), $MachinePrecision] / -3.0), $MachinePrecision] * N[(-1.0 / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1e-63], N[(x + N[(N[(1.0 / y), $MachinePrecision] / N[(N[(z * 3.0), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - N[(N[(y - N[(t / y), $MachinePrecision]), $MachinePrecision] / N[(z * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.3 \cdot 10^{-156}:\\
\;\;\;\;x + \frac{\frac{t}{y} - y}{-3} \cdot \frac{-1}{z}\\
\mathbf{elif}\;y \leq 10^{-63}:\\
\;\;\;\;x + \frac{\frac{1}{y}}{\frac{z \cdot 3}{t}}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y - \frac{t}{y}}{z \cdot 3}\\
\end{array}
\end{array}
if y < -2.3e-156Initial program 96.6%
remove-double-neg96.6%
distribute-frac-neg96.6%
sub-neg96.6%
sub-neg96.6%
distribute-frac-neg96.6%
associate-+r-96.6%
sub-neg96.6%
neg-mul-196.6%
*-commutative96.6%
times-frac96.5%
metadata-eval96.5%
distribute-frac-neg96.5%
remove-double-neg96.5%
associate-*l*96.5%
*-commutative96.5%
associate-/r*93.1%
Simplified93.1%
*-commutative93.1%
div-inv93.0%
associate-*l*93.1%
*-commutative93.1%
div-inv93.1%
div-inv93.2%
times-frac95.4%
associate-/r*95.3%
frac-2neg95.3%
times-frac96.5%
distribute-lft-neg-in96.5%
distribute-rgt-neg-in96.5%
times-frac95.3%
distribute-neg-frac95.3%
distribute-rgt-neg-in95.3%
metadata-eval95.3%
metadata-eval95.3%
div-inv95.3%
clear-num95.3%
distribute-rgt-in97.6%
sub-neg97.6%
Applied egg-rr97.7%
if -2.3e-156 < y < 1.00000000000000007e-63Initial program 85.7%
associate-+l-85.7%
sub-neg85.7%
sub-neg85.7%
distribute-frac-neg85.7%
distribute-neg-in85.7%
distribute-frac-neg85.7%
sub-neg85.7%
neg-mul-185.7%
associate-*l/85.7%
neg-mul-185.7%
times-frac87.3%
distribute-lft-out--87.3%
*-commutative87.3%
associate-/r*87.3%
metadata-eval87.3%
Simplified87.3%
Taylor expanded in y around 0 84.4%
*-commutative84.4%
associate-*l/84.3%
times-frac86.2%
Simplified86.2%
associate-*r/86.2%
associate-/l*86.2%
div-inv86.1%
*-commutative86.1%
div-inv86.2%
metadata-eval86.2%
associate-/l*96.6%
Applied egg-rr96.6%
if 1.00000000000000007e-63 < y Initial program 97.3%
associate-+l-97.3%
sub-neg97.3%
sub-neg97.3%
distribute-frac-neg97.3%
distribute-neg-in97.3%
distribute-frac-neg97.3%
sub-neg97.3%
neg-mul-197.3%
associate-*l/97.2%
neg-mul-197.2%
times-frac98.5%
distribute-lft-out--99.8%
*-commutative99.8%
associate-/r*99.8%
metadata-eval99.8%
Simplified99.8%
sub-neg99.8%
distribute-rgt-in98.5%
div-inv98.4%
*-commutative98.4%
associate-*l*98.4%
div-inv98.4%
*-commutative98.4%
metadata-eval98.4%
metadata-eval98.4%
times-frac98.6%
metadata-eval98.6%
neg-mul-198.6%
*-commutative98.6%
distribute-neg-frac98.6%
distribute-neg-frac98.6%
clear-num98.6%
div-inv98.6%
metadata-eval98.6%
metadata-eval98.6%
distribute-rgt-neg-in98.6%
times-frac97.3%
*-commutative97.3%
times-frac94.9%
Applied egg-rr99.9%
Final simplification98.0%
(FPCore (x y z t) :precision binary64 (if (<= (* z 3.0) -5e+34) x (if (<= (* z 3.0) 2e+65) (/ y (* z -3.0)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if ((z * 3.0) <= -5e+34) {
tmp = x;
} else if ((z * 3.0) <= 2e+65) {
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 ((z * 3.0d0) <= (-5d+34)) then
tmp = x
else if ((z * 3.0d0) <= 2d+65) 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 ((z * 3.0) <= -5e+34) {
tmp = x;
} else if ((z * 3.0) <= 2e+65) {
tmp = y / (z * -3.0);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z * 3.0) <= -5e+34: tmp = x elif (z * 3.0) <= 2e+65: tmp = y / (z * -3.0) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(z * 3.0) <= -5e+34) tmp = x; elseif (Float64(z * 3.0) <= 2e+65) tmp = Float64(y / Float64(z * -3.0)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z * 3.0) <= -5e+34) tmp = x; elseif ((z * 3.0) <= 2e+65) tmp = y / (z * -3.0); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(z * 3.0), $MachinePrecision], -5e+34], x, If[LessEqual[N[(z * 3.0), $MachinePrecision], 2e+65], N[(y / N[(z * -3.0), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot 3 \leq -5 \cdot 10^{+34}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \cdot 3 \leq 2 \cdot 10^{+65}:\\
\;\;\;\;\frac{y}{z \cdot -3}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if (*.f64 z 3) < -4.9999999999999998e34 or 2e65 < (*.f64 z 3) Initial program 99.8%
associate-+l-99.8%
sub-neg99.8%
sub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-in99.8%
distribute-frac-neg99.8%
sub-neg99.8%
neg-mul-199.8%
associate-*l/99.8%
neg-mul-199.8%
times-frac88.2%
distribute-lft-out--88.2%
*-commutative88.2%
associate-/r*88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in x around inf 59.0%
if -4.9999999999999998e34 < (*.f64 z 3) < 2e65Initial program 87.5%
associate-+l-87.5%
sub-neg87.5%
sub-neg87.5%
distribute-frac-neg87.5%
distribute-neg-in87.5%
distribute-frac-neg87.5%
sub-neg87.5%
neg-mul-187.5%
associate-*l/87.5%
neg-mul-187.5%
times-frac97.6%
distribute-lft-out--99.7%
*-commutative99.7%
associate-/r*99.7%
metadata-eval99.7%
Simplified99.7%
sub-neg99.7%
distribute-rgt-in97.6%
div-inv97.6%
*-commutative97.6%
associate-*l*97.6%
div-inv97.6%
*-commutative97.6%
metadata-eval97.6%
metadata-eval97.6%
times-frac97.6%
metadata-eval97.6%
neg-mul-197.6%
*-commutative97.6%
distribute-neg-frac97.6%
distribute-neg-frac97.6%
clear-num97.6%
div-inv97.7%
metadata-eval97.7%
metadata-eval97.7%
distribute-rgt-neg-in97.7%
times-frac87.5%
*-commutative87.5%
times-frac93.6%
Applied egg-rr99.8%
Taylor expanded in x around 0 93.8%
Taylor expanded in y around inf 50.7%
associate-*r/50.7%
*-commutative50.7%
associate-*r/50.7%
Simplified50.7%
associate-*r/50.7%
associate-/l*50.7%
div-inv50.7%
metadata-eval50.7%
Applied egg-rr50.7%
Final simplification54.4%
(FPCore (x y z t)
:precision binary64
(if (<= y -1.2e-15)
(- x (/ (/ y 3.0) z))
(if (<= y 35000000.0)
(+ 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 <= -1.2e-15) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 35000000.0) {
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 <= (-1.2d-15)) then
tmp = x - ((y / 3.0d0) / z)
else if (y <= 35000000.0d0) 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 <= -1.2e-15) {
tmp = x - ((y / 3.0) / z);
} else if (y <= 35000000.0) {
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 <= -1.2e-15: tmp = x - ((y / 3.0) / z) elif y <= 35000000.0: 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 <= -1.2e-15) tmp = Float64(x - Float64(Float64(y / 3.0) / z)); elseif (y <= 35000000.0) 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 <= -1.2e-15) tmp = x - ((y / 3.0) / z); elseif (y <= 35000000.0) 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, -1.2e-15], N[(x - N[(N[(y / 3.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 35000000.0], 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 -1.2 \cdot 10^{-15}:\\
\;\;\;\;x - \frac{\frac{y}{3}}{z}\\
\mathbf{elif}\;y \leq 35000000:\\
\;\;\;\;x + \frac{t \cdot \frac{0.3333333333333333}{z}}{y}\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y}{z \cdot 3}\\
\end{array}
\end{array}
if y < -1.19999999999999997e-15Initial program 96.6%
Taylor expanded in t around 0 89.6%
associate-*r/89.6%
*-commutative89.6%
metadata-eval89.6%
div-inv89.7%
Applied egg-rr89.7%
if -1.19999999999999997e-15 < y < 3.5e7Initial program 89.0%
associate-+l-89.0%
sub-neg89.0%
sub-neg89.0%
distribute-frac-neg89.0%
distribute-neg-in89.0%
distribute-frac-neg89.0%
sub-neg89.0%
neg-mul-189.0%
associate-*l/89.0%
neg-mul-189.0%
times-frac90.0%
distribute-lft-out--90.0%
*-commutative90.0%
associate-/r*90.0%
metadata-eval90.0%
Simplified90.0%
Taylor expanded in y around 0 85.5%
*-commutative85.5%
associate-*l/85.5%
times-frac86.7%
Simplified86.7%
associate-*l/94.3%
Applied egg-rr94.3%
if 3.5e7 < y Initial program 98.2%
Taylor expanded in t around 0 91.7%
*-commutative91.7%
metadata-eval91.7%
div-inv91.7%
associate-/r*91.9%
Applied egg-rr91.9%
Final simplification92.7%
(FPCore (x y z t) :precision binary64 (if (<= z -1.4e+34) x (if (<= z 5.05e+64) (* -0.3333333333333333 (/ y z)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -1.4e+34) {
tmp = x;
} else if (z <= 5.05e+64) {
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 (z <= (-1.4d+34)) then
tmp = x
else if (z <= 5.05d+64) 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 (z <= -1.4e+34) {
tmp = x;
} else if (z <= 5.05e+64) {
tmp = -0.3333333333333333 * (y / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -1.4e+34: tmp = x elif z <= 5.05e+64: tmp = -0.3333333333333333 * (y / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -1.4e+34) tmp = x; elseif (z <= 5.05e+64) 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 (z <= -1.4e+34) tmp = x; elseif (z <= 5.05e+64) tmp = -0.3333333333333333 * (y / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -1.4e+34], x, If[LessEqual[z, 5.05e+64], N[(-0.3333333333333333 * N[(y / z), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.4 \cdot 10^{+34}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 5.05 \cdot 10^{+64}:\\
\;\;\;\;-0.3333333333333333 \cdot \frac{y}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.40000000000000004e34 or 5.0499999999999998e64 < z Initial program 99.8%
associate-+l-99.8%
sub-neg99.8%
sub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-in99.8%
distribute-frac-neg99.8%
sub-neg99.8%
neg-mul-199.8%
associate-*l/99.8%
neg-mul-199.8%
times-frac88.2%
distribute-lft-out--88.2%
*-commutative88.2%
associate-/r*88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in x around inf 59.0%
if -1.40000000000000004e34 < z < 5.0499999999999998e64Initial program 87.5%
associate-+l-87.5%
sub-neg87.5%
sub-neg87.5%
distribute-frac-neg87.5%
distribute-neg-in87.5%
distribute-frac-neg87.5%
sub-neg87.5%
neg-mul-187.5%
associate-*l/87.5%
neg-mul-187.5%
times-frac97.6%
distribute-lft-out--99.7%
*-commutative99.7%
associate-/r*99.7%
metadata-eval99.7%
Simplified99.7%
sub-neg99.7%
distribute-rgt-in97.6%
div-inv97.6%
*-commutative97.6%
associate-*l*97.6%
div-inv97.6%
*-commutative97.6%
metadata-eval97.6%
metadata-eval97.6%
times-frac97.6%
metadata-eval97.6%
neg-mul-197.6%
*-commutative97.6%
distribute-neg-frac97.6%
distribute-neg-frac97.6%
clear-num97.6%
div-inv97.7%
metadata-eval97.7%
metadata-eval97.7%
distribute-rgt-neg-in97.7%
times-frac87.5%
*-commutative87.5%
times-frac93.6%
Applied egg-rr99.8%
Taylor expanded in y around inf 50.7%
Final simplification54.4%
(FPCore (x y z t) :precision binary64 (if (<= z -1.01e+34) x (if (<= z 1.34e+69) (* y (/ -0.3333333333333333 z)) x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -1.01e+34) {
tmp = x;
} else if (z <= 1.34e+69) {
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.01d+34)) then
tmp = x
else if (z <= 1.34d+69) 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.01e+34) {
tmp = x;
} else if (z <= 1.34e+69) {
tmp = y * (-0.3333333333333333 / z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -1.01e+34: tmp = x elif z <= 1.34e+69: tmp = y * (-0.3333333333333333 / z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -1.01e+34) tmp = x; elseif (z <= 1.34e+69) 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.01e+34) tmp = x; elseif (z <= 1.34e+69) tmp = y * (-0.3333333333333333 / z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -1.01e+34], x, If[LessEqual[z, 1.34e+69], N[(y * N[(-0.3333333333333333 / z), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.01 \cdot 10^{+34}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.34 \cdot 10^{+69}:\\
\;\;\;\;y \cdot \frac{-0.3333333333333333}{z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.01e34 or 1.3399999999999999e69 < z Initial program 99.8%
associate-+l-99.8%
sub-neg99.8%
sub-neg99.8%
distribute-frac-neg99.8%
distribute-neg-in99.8%
distribute-frac-neg99.8%
sub-neg99.8%
neg-mul-199.8%
associate-*l/99.8%
neg-mul-199.8%
times-frac88.2%
distribute-lft-out--88.2%
*-commutative88.2%
associate-/r*88.2%
metadata-eval88.2%
Simplified88.2%
Taylor expanded in x around inf 59.0%
if -1.01e34 < z < 1.3399999999999999e69Initial program 87.5%
associate-+l-87.5%
sub-neg87.5%
sub-neg87.5%
distribute-frac-neg87.5%
distribute-neg-in87.5%
distribute-frac-neg87.5%
sub-neg87.5%
neg-mul-187.5%
associate-*l/87.5%
neg-mul-187.5%
times-frac97.6%
distribute-lft-out--99.7%
*-commutative99.7%
associate-/r*99.7%
metadata-eval99.7%
Simplified99.7%
sub-neg99.7%
distribute-rgt-in97.6%
div-inv97.6%
*-commutative97.6%
associate-*l*97.6%
div-inv97.6%
*-commutative97.6%
metadata-eval97.6%
metadata-eval97.6%
times-frac97.6%
metadata-eval97.6%
neg-mul-197.6%
*-commutative97.6%
distribute-neg-frac97.6%
distribute-neg-frac97.6%
clear-num97.6%
div-inv97.7%
metadata-eval97.7%
metadata-eval97.7%
distribute-rgt-neg-in97.7%
times-frac87.5%
*-commutative87.5%
times-frac93.6%
Applied egg-rr99.8%
Taylor expanded in x around 0 93.8%
Taylor expanded in y around inf 50.7%
associate-*r/50.7%
*-commutative50.7%
associate-*r/50.7%
Simplified50.7%
Final simplification54.4%
(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 92.9%
associate-+l-92.9%
sub-neg92.9%
sub-neg92.9%
distribute-frac-neg92.9%
distribute-neg-in92.9%
distribute-frac-neg92.9%
sub-neg92.9%
neg-mul-192.9%
associate-*l/92.9%
neg-mul-192.9%
times-frac93.5%
distribute-lft-out--94.6%
*-commutative94.6%
associate-/r*94.6%
metadata-eval94.6%
Simplified94.6%
Taylor expanded in x around inf 29.9%
Final simplification29.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 2023297
(FPCore (x y z t)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, H"
:precision binary64
:herbie-target
(+ (- x (/ y (* z 3.0))) (/ (/ t (* z 3.0)) y))
(+ (- x (/ y (* z 3.0))) (/ t (* (* z 3.0) y))))