
(FPCore (x y z t) :precision binary64 (/ (* x (- y z)) (- t z)))
double code(double x, double y, double z, double t) {
return (x * (y - z)) / (t - z);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x * (y - z)) / (t - z)
end function
public static double code(double x, double y, double z, double t) {
return (x * (y - z)) / (t - z);
}
def code(x, y, z, t): return (x * (y - z)) / (t - z)
function code(x, y, z, t) return Float64(Float64(x * Float64(y - z)) / Float64(t - z)) end
function tmp = code(x, y, z, t) tmp = (x * (y - z)) / (t - z); end
code[x_, y_, z_, t_] := N[(N[(x * N[(y - z), $MachinePrecision]), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot \left(y - z\right)}{t - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (/ (* x (- y z)) (- t z)))
double code(double x, double y, double z, double t) {
return (x * (y - z)) / (t - z);
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (x * (y - z)) / (t - z)
end function
public static double code(double x, double y, double z, double t) {
return (x * (y - z)) / (t - z);
}
def code(x, y, z, t): return (x * (y - z)) / (t - z)
function code(x, y, z, t) return Float64(Float64(x * Float64(y - z)) / Float64(t - z)) end
function tmp = code(x, y, z, t) tmp = (x * (y - z)) / (t - z); end
code[x_, y_, z_, t_] := N[(N[(x * N[(y - z), $MachinePrecision]), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot \left(y - z\right)}{t - z}
\end{array}
(FPCore (x y z t) :precision binary64 (if (or (<= z -8.6e+81) (not (<= z 6.4e-90))) (/ x (/ (- t z) (- y z))) (* (/ x (- z t)) (- z y))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -8.6e+81) || !(z <= 6.4e-90)) {
tmp = x / ((t - z) / (y - z));
} else {
tmp = (x / (z - t)) * (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 ((z <= (-8.6d+81)) .or. (.not. (z <= 6.4d-90))) then
tmp = x / ((t - z) / (y - z))
else
tmp = (x / (z - t)) * (z - y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -8.6e+81) || !(z <= 6.4e-90)) {
tmp = x / ((t - z) / (y - z));
} else {
tmp = (x / (z - t)) * (z - y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z <= -8.6e+81) or not (z <= 6.4e-90): tmp = x / ((t - z) / (y - z)) else: tmp = (x / (z - t)) * (z - y) return tmp
function code(x, y, z, t) tmp = 0.0 if ((z <= -8.6e+81) || !(z <= 6.4e-90)) tmp = Float64(x / Float64(Float64(t - z) / Float64(y - z))); else tmp = Float64(Float64(x / Float64(z - t)) * Float64(z - y)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z <= -8.6e+81) || ~((z <= 6.4e-90))) tmp = x / ((t - z) / (y - z)); else tmp = (x / (z - t)) * (z - y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[z, -8.6e+81], N[Not[LessEqual[z, 6.4e-90]], $MachinePrecision]], N[(x / N[(N[(t - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(z - t), $MachinePrecision]), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.6 \cdot 10^{+81} \lor \neg \left(z \leq 6.4 \cdot 10^{-90}\right):\\
\;\;\;\;\frac{x}{\frac{t - z}{y - z}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{z - t} \cdot \left(z - y\right)\\
\end{array}
\end{array}
if z < -8.6000000000000003e81 or 6.40000000000000014e-90 < z Initial program 79.8%
associate-/l*99.8%
Simplified99.8%
clear-num99.7%
un-div-inv99.8%
Applied egg-rr99.8%
if -8.6000000000000003e81 < z < 6.40000000000000014e-90Initial program 90.9%
associate-/l*89.9%
Simplified89.9%
Taylor expanded in x around 0 90.9%
remove-double-neg90.9%
distribute-neg-frac290.9%
*-commutative90.9%
associate-/l*97.4%
distribute-lft-neg-out97.4%
neg-sub097.4%
associate--r-97.4%
neg-sub097.4%
+-commutative97.4%
sub-neg97.4%
neg-sub097.4%
associate--r-97.4%
neg-sub097.4%
+-commutative97.4%
sub-neg97.4%
*-commutative97.4%
Simplified97.4%
Final simplification98.7%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* (- y z) (/ x t))))
(if (<= z -1.05e-106)
(* x (/ (- z y) z))
(if (<= z -9.5e-172)
t_1
(if (<= z -3e-180)
(/ (* x (- y)) z)
(if (<= z 5.4e+14)
t_1
(if (<= z 1.3e+97)
(* (- z y) (/ x z))
(if (<= z 1.55e+97)
(* z (/ x (- t)))
(if (or (<= z 2.15e+148) (not (<= z 2.2e+148)))
(* x (- 1.0 (/ y z)))
(* x (/ (- z) t)))))))))))
double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 5.4e+14) {
tmp = t_1;
} else if (z <= 1.3e+97) {
tmp = (z - y) * (x / z);
} else if (z <= 1.55e+97) {
tmp = z * (x / -t);
} else if ((z <= 2.15e+148) || !(z <= 2.2e+148)) {
tmp = x * (1.0 - (y / z));
} else {
tmp = x * (-z / 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) :: t_1
real(8) :: tmp
t_1 = (y - z) * (x / t)
if (z <= (-1.05d-106)) then
tmp = x * ((z - y) / z)
else if (z <= (-9.5d-172)) then
tmp = t_1
else if (z <= (-3d-180)) then
tmp = (x * -y) / z
else if (z <= 5.4d+14) then
tmp = t_1
else if (z <= 1.3d+97) then
tmp = (z - y) * (x / z)
else if (z <= 1.55d+97) then
tmp = z * (x / -t)
else if ((z <= 2.15d+148) .or. (.not. (z <= 2.2d+148))) then
tmp = x * (1.0d0 - (y / z))
else
tmp = x * (-z / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 5.4e+14) {
tmp = t_1;
} else if (z <= 1.3e+97) {
tmp = (z - y) * (x / z);
} else if (z <= 1.55e+97) {
tmp = z * (x / -t);
} else if ((z <= 2.15e+148) || !(z <= 2.2e+148)) {
tmp = x * (1.0 - (y / z));
} else {
tmp = x * (-z / t);
}
return tmp;
}
def code(x, y, z, t): t_1 = (y - z) * (x / t) tmp = 0 if z <= -1.05e-106: tmp = x * ((z - y) / z) elif z <= -9.5e-172: tmp = t_1 elif z <= -3e-180: tmp = (x * -y) / z elif z <= 5.4e+14: tmp = t_1 elif z <= 1.3e+97: tmp = (z - y) * (x / z) elif z <= 1.55e+97: tmp = z * (x / -t) elif (z <= 2.15e+148) or not (z <= 2.2e+148): tmp = x * (1.0 - (y / z)) else: tmp = x * (-z / t) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(y - z) * Float64(x / t)) tmp = 0.0 if (z <= -1.05e-106) tmp = Float64(x * Float64(Float64(z - y) / z)); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = Float64(Float64(x * Float64(-y)) / z); elseif (z <= 5.4e+14) tmp = t_1; elseif (z <= 1.3e+97) tmp = Float64(Float64(z - y) * Float64(x / z)); elseif (z <= 1.55e+97) tmp = Float64(z * Float64(x / Float64(-t))); elseif ((z <= 2.15e+148) || !(z <= 2.2e+148)) tmp = Float64(x * Float64(1.0 - Float64(y / z))); else tmp = Float64(x * Float64(Float64(-z) / t)); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (y - z) * (x / t); tmp = 0.0; if (z <= -1.05e-106) tmp = x * ((z - y) / z); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = (x * -y) / z; elseif (z <= 5.4e+14) tmp = t_1; elseif (z <= 1.3e+97) tmp = (z - y) * (x / z); elseif (z <= 1.55e+97) tmp = z * (x / -t); elseif ((z <= 2.15e+148) || ~((z <= 2.2e+148))) tmp = x * (1.0 - (y / z)); else tmp = x * (-z / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(x / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.05e-106], N[(x * N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.5e-172], t$95$1, If[LessEqual[z, -3e-180], N[(N[(x * (-y)), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 5.4e+14], t$95$1, If[LessEqual[z, 1.3e+97], N[(N[(z - y), $MachinePrecision] * N[(x / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.55e+97], N[(z * N[(x / (-t)), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, 2.15e+148], N[Not[LessEqual[z, 2.2e+148]], $MachinePrecision]], N[(x * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[((-z) / t), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{x}{t}\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{-106}:\\
\;\;\;\;x \cdot \frac{z - y}{z}\\
\mathbf{elif}\;z \leq -9.5 \cdot 10^{-172}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-180}:\\
\;\;\;\;\frac{x \cdot \left(-y\right)}{z}\\
\mathbf{elif}\;z \leq 5.4 \cdot 10^{+14}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.3 \cdot 10^{+97}:\\
\;\;\;\;\left(z - y\right) \cdot \frac{x}{z}\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{+97}:\\
\;\;\;\;z \cdot \frac{x}{-t}\\
\mathbf{elif}\;z \leq 2.15 \cdot 10^{+148} \lor \neg \left(z \leq 2.2 \cdot 10^{+148}\right):\\
\;\;\;\;x \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{-z}{t}\\
\end{array}
\end{array}
if z < -1.05000000000000002e-106Initial program 84.1%
associate-/l*98.9%
Simplified98.9%
Taylor expanded in x around 0 84.1%
remove-double-neg84.1%
distribute-neg-frac284.1%
*-commutative84.1%
associate-/l*78.1%
distribute-lft-neg-out78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in t around 0 59.1%
associate-/l*73.6%
Simplified73.6%
if -1.05000000000000002e-106 < z < -9.50000000000000053e-172 or -3.0000000000000001e-180 < z < 5.4e14Initial program 91.6%
associate-/l*89.8%
Simplified89.8%
clear-num89.8%
un-div-inv89.8%
Applied egg-rr89.8%
Taylor expanded in t around inf 78.8%
*-commutative78.8%
associate-/l*82.4%
Simplified82.4%
if -9.50000000000000053e-172 < z < -3.0000000000000001e-180Initial program 99.8%
associate-/l*86.4%
Simplified86.4%
Taylor expanded in x around 0 99.8%
remove-double-neg99.8%
distribute-neg-frac299.8%
*-commutative99.8%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.8%
associate-/l*33.0%
Simplified33.0%
Taylor expanded in z around 0 99.8%
associate-*r/99.8%
neg-mul-199.8%
distribute-rgt-neg-in99.8%
Simplified99.8%
if 5.4e14 < z < 1.3e97Initial program 77.5%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in x around 0 77.5%
remove-double-neg77.5%
distribute-neg-frac277.5%
*-commutative77.5%
associate-/l*99.7%
distribute-lft-neg-out99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in z around inf 63.0%
if 1.3e97 < z < 1.54999999999999991e97Initial program 100.0%
associate-/l*98.4%
Simplified98.4%
clear-num98.4%
un-div-inv100.0%
Applied egg-rr100.0%
Taylor expanded in y around 0 100.0%
mul-1-neg100.0%
Simplified100.0%
Taylor expanded in t around inf 100.0%
associate-*r/100.0%
mul-1-neg100.0%
distribute-rgt-neg-out100.0%
associate-*l/100.0%
Simplified100.0%
if 1.54999999999999991e97 < z < 2.1500000000000001e148 or 2.1999999999999999e148 < z Initial program 72.6%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in t around 0 57.9%
mul-1-neg57.9%
associate-/l*83.2%
distribute-rgt-neg-in83.2%
distribute-frac-neg83.2%
neg-sub083.2%
associate--r-83.2%
neg-sub083.2%
+-commutative83.2%
sub-neg83.2%
div-sub83.2%
*-inverses83.2%
Simplified83.2%
if 2.1500000000000001e148 < z < 2.1999999999999999e148Initial program 100.0%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in t around inf 100.0%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in y around 0 100.0%
neg-mul-1100.0%
distribute-neg-frac2100.0%
Simplified100.0%
Final simplification79.0%
(FPCore (x y z t)
:precision binary64
(if (<= z -2.2e+90)
x
(if (<= z -5.5e-15)
(* y (/ x t))
(if (<= z -9e-57)
(/ (* z x) z)
(if (<= z -1.15e-171)
(/ (* z (- x)) t)
(if (<= z -6.8e-176)
(* y (/ x (- z)))
(if (<= z 6e+15)
(/ y (/ t x))
(if (<= z 4.1e+70)
x
(if (<= z 9.5e+83) (/ y (/ z (- x))) x)))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -2.2e+90) {
tmp = x;
} else if (z <= -5.5e-15) {
tmp = y * (x / t);
} else if (z <= -9e-57) {
tmp = (z * x) / z;
} else if (z <= -1.15e-171) {
tmp = (z * -x) / t;
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= 6e+15) {
tmp = y / (t / x);
} else if (z <= 4.1e+70) {
tmp = x;
} else if (z <= 9.5e+83) {
tmp = y / (z / -x);
} 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 <= (-2.2d+90)) then
tmp = x
else if (z <= (-5.5d-15)) then
tmp = y * (x / t)
else if (z <= (-9d-57)) then
tmp = (z * x) / z
else if (z <= (-1.15d-171)) then
tmp = (z * -x) / t
else if (z <= (-6.8d-176)) then
tmp = y * (x / -z)
else if (z <= 6d+15) then
tmp = y / (t / x)
else if (z <= 4.1d+70) then
tmp = x
else if (z <= 9.5d+83) then
tmp = y / (z / -x)
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 <= -2.2e+90) {
tmp = x;
} else if (z <= -5.5e-15) {
tmp = y * (x / t);
} else if (z <= -9e-57) {
tmp = (z * x) / z;
} else if (z <= -1.15e-171) {
tmp = (z * -x) / t;
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= 6e+15) {
tmp = y / (t / x);
} else if (z <= 4.1e+70) {
tmp = x;
} else if (z <= 9.5e+83) {
tmp = y / (z / -x);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -2.2e+90: tmp = x elif z <= -5.5e-15: tmp = y * (x / t) elif z <= -9e-57: tmp = (z * x) / z elif z <= -1.15e-171: tmp = (z * -x) / t elif z <= -6.8e-176: tmp = y * (x / -z) elif z <= 6e+15: tmp = y / (t / x) elif z <= 4.1e+70: tmp = x elif z <= 9.5e+83: tmp = y / (z / -x) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -2.2e+90) tmp = x; elseif (z <= -5.5e-15) tmp = Float64(y * Float64(x / t)); elseif (z <= -9e-57) tmp = Float64(Float64(z * x) / z); elseif (z <= -1.15e-171) tmp = Float64(Float64(z * Float64(-x)) / t); elseif (z <= -6.8e-176) tmp = Float64(y * Float64(x / Float64(-z))); elseif (z <= 6e+15) tmp = Float64(y / Float64(t / x)); elseif (z <= 4.1e+70) tmp = x; elseif (z <= 9.5e+83) tmp = Float64(y / Float64(z / Float64(-x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -2.2e+90) tmp = x; elseif (z <= -5.5e-15) tmp = y * (x / t); elseif (z <= -9e-57) tmp = (z * x) / z; elseif (z <= -1.15e-171) tmp = (z * -x) / t; elseif (z <= -6.8e-176) tmp = y * (x / -z); elseif (z <= 6e+15) tmp = y / (t / x); elseif (z <= 4.1e+70) tmp = x; elseif (z <= 9.5e+83) tmp = y / (z / -x); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -2.2e+90], x, If[LessEqual[z, -5.5e-15], N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9e-57], N[(N[(z * x), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -1.15e-171], N[(N[(z * (-x)), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[z, -6.8e-176], N[(y * N[(x / (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6e+15], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.1e+70], x, If[LessEqual[z, 9.5e+83], N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision], x]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.2 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -5.5 \cdot 10^{-15}:\\
\;\;\;\;y \cdot \frac{x}{t}\\
\mathbf{elif}\;z \leq -9 \cdot 10^{-57}:\\
\;\;\;\;\frac{z \cdot x}{z}\\
\mathbf{elif}\;z \leq -1.15 \cdot 10^{-171}:\\
\;\;\;\;\frac{z \cdot \left(-x\right)}{t}\\
\mathbf{elif}\;z \leq -6.8 \cdot 10^{-176}:\\
\;\;\;\;y \cdot \frac{x}{-z}\\
\mathbf{elif}\;z \leq 6 \cdot 10^{+15}:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 4.1 \cdot 10^{+70}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 9.5 \cdot 10^{+83}:\\
\;\;\;\;\frac{y}{\frac{z}{-x}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.1999999999999999e90 or 6e15 < z < 4.1000000000000002e70 or 9.5000000000000002e83 < z Initial program 75.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 67.7%
if -2.1999999999999999e90 < z < -5.5000000000000002e-15Initial program 90.1%
associate-/l*99.8%
Simplified99.8%
clear-num99.8%
un-div-inv99.8%
Applied egg-rr99.8%
Taylor expanded in z around 0 38.4%
associate-/r/38.4%
Applied egg-rr38.4%
if -5.5000000000000002e-15 < z < -8.99999999999999945e-57Initial program 100.0%
remove-double-neg100.0%
distribute-lft-neg-out100.0%
distribute-neg-frac100.0%
distribute-neg-frac2100.0%
distribute-lft-neg-out100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in t around 0 66.8%
Taylor expanded in z around inf 55.8%
if -8.99999999999999945e-57 < z < -1.14999999999999989e-171Initial program 97.8%
associate-/l*87.2%
Simplified87.2%
Taylor expanded in t around inf 66.4%
associate-/l*53.8%
Simplified53.8%
Taylor expanded in y around 0 52.9%
associate-*r/52.9%
neg-mul-152.9%
*-commutative52.9%
distribute-lft-neg-in52.9%
Simplified52.9%
if -1.14999999999999989e-171 < z < -6.7999999999999994e-176Initial program 99.7%
associate-/l*81.0%
Simplified81.0%
Taylor expanded in x around 0 99.7%
remove-double-neg99.7%
distribute-neg-frac299.7%
*-commutative99.7%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.7%
associate-/l*43.9%
Simplified43.9%
Taylor expanded in z around 0 99.7%
associate-*r/99.7%
neg-mul-199.7%
distribute-rgt-neg-in99.7%
Simplified99.7%
Taylor expanded in x around 0 99.7%
mul-1-neg99.7%
associate-*l/100.0%
Simplified100.0%
if -6.7999999999999994e-176 < z < 6e15Initial program 90.8%
associate-/l*90.9%
Simplified90.9%
clear-num90.8%
un-div-inv90.9%
Applied egg-rr90.9%
Taylor expanded in z around 0 69.1%
associate-/r/70.5%
Applied egg-rr70.5%
*-commutative70.5%
clear-num70.5%
un-div-inv70.5%
Applied egg-rr70.5%
if 4.1000000000000002e70 < z < 9.5000000000000002e83Initial program 62.3%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in x around 0 62.3%
remove-double-neg62.3%
distribute-neg-frac262.3%
*-commutative62.3%
associate-/l*99.7%
distribute-lft-neg-out99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 23.7%
associate-/l*42.3%
Simplified42.3%
Taylor expanded in z around 0 33.0%
associate-*r/33.0%
neg-mul-133.0%
distribute-rgt-neg-in33.0%
Simplified33.0%
Taylor expanded in x around 0 33.0%
mul-1-neg33.0%
associate-*l/51.6%
Simplified51.6%
*-commutative51.6%
clear-num51.6%
un-div-inv51.6%
Applied egg-rr51.6%
Final simplification65.3%
(FPCore (x y z t)
:precision binary64
(if (<= z -2.2e+90)
x
(if (<= z -5.2e-14)
(* y (/ x t))
(if (<= z -1.15e-55)
(/ (* z x) z)
(if (<= z -1.5e-111)
(/ (* x (- y)) z)
(if (<= z -5.5e-158)
(* z (/ x (- t)))
(if (<= z 33000000000000.0)
(/ y (/ t x))
(if (<= z 9e+74) x (if (<= z 3.4e+84) (/ y (/ z (- x))) x)))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -2.2e+90) {
tmp = x;
} else if (z <= -5.2e-14) {
tmp = y * (x / t);
} else if (z <= -1.15e-55) {
tmp = (z * x) / z;
} else if (z <= -1.5e-111) {
tmp = (x * -y) / z;
} else if (z <= -5.5e-158) {
tmp = z * (x / -t);
} else if (z <= 33000000000000.0) {
tmp = y / (t / x);
} else if (z <= 9e+74) {
tmp = x;
} else if (z <= 3.4e+84) {
tmp = y / (z / -x);
} 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 <= (-2.2d+90)) then
tmp = x
else if (z <= (-5.2d-14)) then
tmp = y * (x / t)
else if (z <= (-1.15d-55)) then
tmp = (z * x) / z
else if (z <= (-1.5d-111)) then
tmp = (x * -y) / z
else if (z <= (-5.5d-158)) then
tmp = z * (x / -t)
else if (z <= 33000000000000.0d0) then
tmp = y / (t / x)
else if (z <= 9d+74) then
tmp = x
else if (z <= 3.4d+84) then
tmp = y / (z / -x)
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 <= -2.2e+90) {
tmp = x;
} else if (z <= -5.2e-14) {
tmp = y * (x / t);
} else if (z <= -1.15e-55) {
tmp = (z * x) / z;
} else if (z <= -1.5e-111) {
tmp = (x * -y) / z;
} else if (z <= -5.5e-158) {
tmp = z * (x / -t);
} else if (z <= 33000000000000.0) {
tmp = y / (t / x);
} else if (z <= 9e+74) {
tmp = x;
} else if (z <= 3.4e+84) {
tmp = y / (z / -x);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -2.2e+90: tmp = x elif z <= -5.2e-14: tmp = y * (x / t) elif z <= -1.15e-55: tmp = (z * x) / z elif z <= -1.5e-111: tmp = (x * -y) / z elif z <= -5.5e-158: tmp = z * (x / -t) elif z <= 33000000000000.0: tmp = y / (t / x) elif z <= 9e+74: tmp = x elif z <= 3.4e+84: tmp = y / (z / -x) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -2.2e+90) tmp = x; elseif (z <= -5.2e-14) tmp = Float64(y * Float64(x / t)); elseif (z <= -1.15e-55) tmp = Float64(Float64(z * x) / z); elseif (z <= -1.5e-111) tmp = Float64(Float64(x * Float64(-y)) / z); elseif (z <= -5.5e-158) tmp = Float64(z * Float64(x / Float64(-t))); elseif (z <= 33000000000000.0) tmp = Float64(y / Float64(t / x)); elseif (z <= 9e+74) tmp = x; elseif (z <= 3.4e+84) tmp = Float64(y / Float64(z / Float64(-x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -2.2e+90) tmp = x; elseif (z <= -5.2e-14) tmp = y * (x / t); elseif (z <= -1.15e-55) tmp = (z * x) / z; elseif (z <= -1.5e-111) tmp = (x * -y) / z; elseif (z <= -5.5e-158) tmp = z * (x / -t); elseif (z <= 33000000000000.0) tmp = y / (t / x); elseif (z <= 9e+74) tmp = x; elseif (z <= 3.4e+84) tmp = y / (z / -x); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -2.2e+90], x, If[LessEqual[z, -5.2e-14], N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.15e-55], N[(N[(z * x), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -1.5e-111], N[(N[(x * (-y)), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -5.5e-158], N[(z * N[(x / (-t)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 33000000000000.0], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9e+74], x, If[LessEqual[z, 3.4e+84], N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision], x]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.2 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -5.2 \cdot 10^{-14}:\\
\;\;\;\;y \cdot \frac{x}{t}\\
\mathbf{elif}\;z \leq -1.15 \cdot 10^{-55}:\\
\;\;\;\;\frac{z \cdot x}{z}\\
\mathbf{elif}\;z \leq -1.5 \cdot 10^{-111}:\\
\;\;\;\;\frac{x \cdot \left(-y\right)}{z}\\
\mathbf{elif}\;z \leq -5.5 \cdot 10^{-158}:\\
\;\;\;\;z \cdot \frac{x}{-t}\\
\mathbf{elif}\;z \leq 33000000000000:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 9 \cdot 10^{+74}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 3.4 \cdot 10^{+84}:\\
\;\;\;\;\frac{y}{\frac{z}{-x}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.1999999999999999e90 or 3.3e13 < z < 8.9999999999999999e74 or 3.3999999999999998e84 < z Initial program 75.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 67.7%
if -2.1999999999999999e90 < z < -5.19999999999999993e-14Initial program 90.1%
associate-/l*99.8%
Simplified99.8%
clear-num99.8%
un-div-inv99.8%
Applied egg-rr99.8%
Taylor expanded in z around 0 38.4%
associate-/r/38.4%
Applied egg-rr38.4%
if -5.19999999999999993e-14 < z < -1.15000000000000006e-55Initial program 100.0%
remove-double-neg100.0%
distribute-lft-neg-out100.0%
distribute-neg-frac100.0%
distribute-neg-frac2100.0%
distribute-lft-neg-out100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in t around 0 66.8%
Taylor expanded in z around inf 55.8%
if -1.15000000000000006e-55 < z < -1.50000000000000004e-111Initial program 95.9%
associate-/l*93.8%
Simplified93.8%
Taylor expanded in x around 0 95.9%
remove-double-neg95.9%
distribute-neg-frac295.9%
*-commutative95.9%
associate-/l*99.7%
distribute-lft-neg-out99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 63.3%
associate-/l*57.9%
Simplified57.9%
Taylor expanded in z around 0 60.9%
associate-*r/60.9%
neg-mul-160.9%
distribute-rgt-neg-in60.9%
Simplified60.9%
if -1.50000000000000004e-111 < z < -5.50000000000000025e-158Initial program 99.6%
associate-/l*86.0%
Simplified86.0%
clear-num86.0%
un-div-inv86.0%
Applied egg-rr86.0%
Taylor expanded in y around 0 45.9%
mul-1-neg45.9%
Simplified45.9%
Taylor expanded in t around inf 59.7%
associate-*r/59.7%
mul-1-neg59.7%
distribute-rgt-neg-out59.7%
associate-*l/59.2%
Simplified59.2%
if -5.50000000000000025e-158 < z < 3.3e13Initial program 91.5%
associate-/l*89.7%
Simplified89.7%
clear-num89.7%
un-div-inv89.7%
Applied egg-rr89.7%
Taylor expanded in z around 0 67.8%
associate-/r/69.0%
Applied egg-rr69.0%
*-commutative69.0%
clear-num69.0%
un-div-inv69.0%
Applied egg-rr69.0%
if 8.9999999999999999e74 < z < 3.3999999999999998e84Initial program 62.3%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in x around 0 62.3%
remove-double-neg62.3%
distribute-neg-frac262.3%
*-commutative62.3%
associate-/l*99.7%
distribute-lft-neg-out99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 23.7%
associate-/l*42.3%
Simplified42.3%
Taylor expanded in z around 0 33.0%
associate-*r/33.0%
neg-mul-133.0%
distribute-rgt-neg-in33.0%
Simplified33.0%
Taylor expanded in x around 0 33.0%
mul-1-neg33.0%
associate-*l/51.6%
Simplified51.6%
*-commutative51.6%
clear-num51.6%
un-div-inv51.6%
Applied egg-rr51.6%
Final simplification64.8%
(FPCore (x y z t)
:precision binary64
(if (<= z -2.8e+90)
x
(if (<= z -3.4e-13)
(* y (/ x t))
(if (<= z -1.15e-55)
(/ (* z x) z)
(if (<= z -3.7e-171)
(* z (/ x (- t)))
(if (<= z -6.8e-176)
(* y (/ x (- z)))
(if (<= z 4.9e+14)
(/ y (/ t x))
(if (<= z 2.3e+70)
x
(if (<= z 1.22e+84) (/ y (/ z (- x))) x)))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -2.8e+90) {
tmp = x;
} else if (z <= -3.4e-13) {
tmp = y * (x / t);
} else if (z <= -1.15e-55) {
tmp = (z * x) / z;
} else if (z <= -3.7e-171) {
tmp = z * (x / -t);
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= 4.9e+14) {
tmp = y / (t / x);
} else if (z <= 2.3e+70) {
tmp = x;
} else if (z <= 1.22e+84) {
tmp = y / (z / -x);
} 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 <= (-2.8d+90)) then
tmp = x
else if (z <= (-3.4d-13)) then
tmp = y * (x / t)
else if (z <= (-1.15d-55)) then
tmp = (z * x) / z
else if (z <= (-3.7d-171)) then
tmp = z * (x / -t)
else if (z <= (-6.8d-176)) then
tmp = y * (x / -z)
else if (z <= 4.9d+14) then
tmp = y / (t / x)
else if (z <= 2.3d+70) then
tmp = x
else if (z <= 1.22d+84) then
tmp = y / (z / -x)
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 <= -2.8e+90) {
tmp = x;
} else if (z <= -3.4e-13) {
tmp = y * (x / t);
} else if (z <= -1.15e-55) {
tmp = (z * x) / z;
} else if (z <= -3.7e-171) {
tmp = z * (x / -t);
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= 4.9e+14) {
tmp = y / (t / x);
} else if (z <= 2.3e+70) {
tmp = x;
} else if (z <= 1.22e+84) {
tmp = y / (z / -x);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -2.8e+90: tmp = x elif z <= -3.4e-13: tmp = y * (x / t) elif z <= -1.15e-55: tmp = (z * x) / z elif z <= -3.7e-171: tmp = z * (x / -t) elif z <= -6.8e-176: tmp = y * (x / -z) elif z <= 4.9e+14: tmp = y / (t / x) elif z <= 2.3e+70: tmp = x elif z <= 1.22e+84: tmp = y / (z / -x) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -2.8e+90) tmp = x; elseif (z <= -3.4e-13) tmp = Float64(y * Float64(x / t)); elseif (z <= -1.15e-55) tmp = Float64(Float64(z * x) / z); elseif (z <= -3.7e-171) tmp = Float64(z * Float64(x / Float64(-t))); elseif (z <= -6.8e-176) tmp = Float64(y * Float64(x / Float64(-z))); elseif (z <= 4.9e+14) tmp = Float64(y / Float64(t / x)); elseif (z <= 2.3e+70) tmp = x; elseif (z <= 1.22e+84) tmp = Float64(y / Float64(z / Float64(-x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -2.8e+90) tmp = x; elseif (z <= -3.4e-13) tmp = y * (x / t); elseif (z <= -1.15e-55) tmp = (z * x) / z; elseif (z <= -3.7e-171) tmp = z * (x / -t); elseif (z <= -6.8e-176) tmp = y * (x / -z); elseif (z <= 4.9e+14) tmp = y / (t / x); elseif (z <= 2.3e+70) tmp = x; elseif (z <= 1.22e+84) tmp = y / (z / -x); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -2.8e+90], x, If[LessEqual[z, -3.4e-13], N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.15e-55], N[(N[(z * x), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, -3.7e-171], N[(z * N[(x / (-t)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -6.8e-176], N[(y * N[(x / (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.9e+14], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.3e+70], x, If[LessEqual[z, 1.22e+84], N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision], x]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.8 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -3.4 \cdot 10^{-13}:\\
\;\;\;\;y \cdot \frac{x}{t}\\
\mathbf{elif}\;z \leq -1.15 \cdot 10^{-55}:\\
\;\;\;\;\frac{z \cdot x}{z}\\
\mathbf{elif}\;z \leq -3.7 \cdot 10^{-171}:\\
\;\;\;\;z \cdot \frac{x}{-t}\\
\mathbf{elif}\;z \leq -6.8 \cdot 10^{-176}:\\
\;\;\;\;y \cdot \frac{x}{-z}\\
\mathbf{elif}\;z \leq 4.9 \cdot 10^{+14}:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 2.3 \cdot 10^{+70}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.22 \cdot 10^{+84}:\\
\;\;\;\;\frac{y}{\frac{z}{-x}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.8e90 or 4.9e14 < z < 2.29999999999999994e70 or 1.2200000000000001e84 < z Initial program 75.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 67.7%
if -2.8e90 < z < -3.40000000000000015e-13Initial program 90.1%
associate-/l*99.8%
Simplified99.8%
clear-num99.8%
un-div-inv99.8%
Applied egg-rr99.8%
Taylor expanded in z around 0 38.4%
associate-/r/38.4%
Applied egg-rr38.4%
if -3.40000000000000015e-13 < z < -1.15000000000000006e-55Initial program 100.0%
remove-double-neg100.0%
distribute-lft-neg-out100.0%
distribute-neg-frac100.0%
distribute-neg-frac2100.0%
distribute-lft-neg-out100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in t around 0 66.8%
Taylor expanded in z around inf 55.8%
if -1.15000000000000006e-55 < z < -3.70000000000000012e-171Initial program 97.8%
associate-/l*87.2%
Simplified87.2%
clear-num85.3%
un-div-inv85.3%
Applied egg-rr85.3%
Taylor expanded in y around 0 38.3%
mul-1-neg38.3%
Simplified38.3%
Taylor expanded in t around inf 52.9%
associate-*r/52.9%
mul-1-neg52.9%
distribute-rgt-neg-out52.9%
associate-*l/52.7%
Simplified52.7%
if -3.70000000000000012e-171 < z < -6.7999999999999994e-176Initial program 99.7%
associate-/l*81.0%
Simplified81.0%
Taylor expanded in x around 0 99.7%
remove-double-neg99.7%
distribute-neg-frac299.7%
*-commutative99.7%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.7%
associate-/l*43.9%
Simplified43.9%
Taylor expanded in z around 0 99.7%
associate-*r/99.7%
neg-mul-199.7%
distribute-rgt-neg-in99.7%
Simplified99.7%
Taylor expanded in x around 0 99.7%
mul-1-neg99.7%
associate-*l/100.0%
Simplified100.0%
if -6.7999999999999994e-176 < z < 4.9e14Initial program 90.8%
associate-/l*90.9%
Simplified90.9%
clear-num90.8%
un-div-inv90.9%
Applied egg-rr90.9%
Taylor expanded in z around 0 69.1%
associate-/r/70.5%
Applied egg-rr70.5%
*-commutative70.5%
clear-num70.5%
un-div-inv70.5%
Applied egg-rr70.5%
if 2.29999999999999994e70 < z < 1.2200000000000001e84Initial program 62.3%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in x around 0 62.3%
remove-double-neg62.3%
distribute-neg-frac262.3%
*-commutative62.3%
associate-/l*99.7%
distribute-lft-neg-out99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 23.7%
associate-/l*42.3%
Simplified42.3%
Taylor expanded in z around 0 33.0%
associate-*r/33.0%
neg-mul-133.0%
distribute-rgt-neg-in33.0%
Simplified33.0%
Taylor expanded in x around 0 33.0%
mul-1-neg33.0%
associate-*l/51.6%
Simplified51.6%
*-commutative51.6%
clear-num51.6%
un-div-inv51.6%
Applied egg-rr51.6%
Final simplification65.3%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* x (/ (- y z) t))))
(if (<= z -1e-106)
(* x (/ (- z y) z))
(if (<= z -9.95e-173)
t_1
(if (<= z -6.8e-176)
(* y (/ x (- z)))
(if (<= z -3.5e-186)
(* x (/ y t))
(if (<= z -8.6e-187)
(/ y (/ z (- x)))
(if (<= z 34000000000000.0) t_1 (* x (- 1.0 (/ y z)))))))))))
double code(double x, double y, double z, double t) {
double t_1 = x * ((y - z) / t);
double tmp;
if (z <= -1e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.95e-173) {
tmp = t_1;
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= -3.5e-186) {
tmp = x * (y / t);
} else if (z <= -8.6e-187) {
tmp = y / (z / -x);
} else if (z <= 34000000000000.0) {
tmp = t_1;
} else {
tmp = x * (1.0 - (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) :: t_1
real(8) :: tmp
t_1 = x * ((y - z) / t)
if (z <= (-1d-106)) then
tmp = x * ((z - y) / z)
else if (z <= (-9.95d-173)) then
tmp = t_1
else if (z <= (-6.8d-176)) then
tmp = y * (x / -z)
else if (z <= (-3.5d-186)) then
tmp = x * (y / t)
else if (z <= (-8.6d-187)) then
tmp = y / (z / -x)
else if (z <= 34000000000000.0d0) then
tmp = t_1
else
tmp = x * (1.0d0 - (y / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = x * ((y - z) / t);
double tmp;
if (z <= -1e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.95e-173) {
tmp = t_1;
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= -3.5e-186) {
tmp = x * (y / t);
} else if (z <= -8.6e-187) {
tmp = y / (z / -x);
} else if (z <= 34000000000000.0) {
tmp = t_1;
} else {
tmp = x * (1.0 - (y / z));
}
return tmp;
}
def code(x, y, z, t): t_1 = x * ((y - z) / t) tmp = 0 if z <= -1e-106: tmp = x * ((z - y) / z) elif z <= -9.95e-173: tmp = t_1 elif z <= -6.8e-176: tmp = y * (x / -z) elif z <= -3.5e-186: tmp = x * (y / t) elif z <= -8.6e-187: tmp = y / (z / -x) elif z <= 34000000000000.0: tmp = t_1 else: tmp = x * (1.0 - (y / z)) return tmp
function code(x, y, z, t) t_1 = Float64(x * Float64(Float64(y - z) / t)) tmp = 0.0 if (z <= -1e-106) tmp = Float64(x * Float64(Float64(z - y) / z)); elseif (z <= -9.95e-173) tmp = t_1; elseif (z <= -6.8e-176) tmp = Float64(y * Float64(x / Float64(-z))); elseif (z <= -3.5e-186) tmp = Float64(x * Float64(y / t)); elseif (z <= -8.6e-187) tmp = Float64(y / Float64(z / Float64(-x))); elseif (z <= 34000000000000.0) tmp = t_1; else tmp = Float64(x * Float64(1.0 - Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x * ((y - z) / t); tmp = 0.0; if (z <= -1e-106) tmp = x * ((z - y) / z); elseif (z <= -9.95e-173) tmp = t_1; elseif (z <= -6.8e-176) tmp = y * (x / -z); elseif (z <= -3.5e-186) tmp = x * (y / t); elseif (z <= -8.6e-187) tmp = y / (z / -x); elseif (z <= 34000000000000.0) tmp = t_1; else tmp = x * (1.0 - (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[(N[(y - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1e-106], N[(x * N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.95e-173], t$95$1, If[LessEqual[z, -6.8e-176], N[(y * N[(x / (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.5e-186], N[(x * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -8.6e-187], N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 34000000000000.0], t$95$1, N[(x * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y - z}{t}\\
\mathbf{if}\;z \leq -1 \cdot 10^{-106}:\\
\;\;\;\;x \cdot \frac{z - y}{z}\\
\mathbf{elif}\;z \leq -9.95 \cdot 10^{-173}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -6.8 \cdot 10^{-176}:\\
\;\;\;\;y \cdot \frac{x}{-z}\\
\mathbf{elif}\;z \leq -3.5 \cdot 10^{-186}:\\
\;\;\;\;x \cdot \frac{y}{t}\\
\mathbf{elif}\;z \leq -8.6 \cdot 10^{-187}:\\
\;\;\;\;\frac{y}{\frac{z}{-x}}\\
\mathbf{elif}\;z \leq 34000000000000:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{z}\right)\\
\end{array}
\end{array}
if z < -9.99999999999999941e-107Initial program 84.1%
associate-/l*98.9%
Simplified98.9%
Taylor expanded in x around 0 84.1%
remove-double-neg84.1%
distribute-neg-frac284.1%
*-commutative84.1%
associate-/l*78.1%
distribute-lft-neg-out78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in t around 0 59.1%
associate-/l*73.6%
Simplified73.6%
if -9.99999999999999941e-107 < z < -9.9499999999999999e-173 or -8.60000000000000001e-187 < z < 3.4e13Initial program 92.4%
associate-/l*89.6%
Simplified89.6%
Taylor expanded in t around inf 79.3%
associate-/l*78.4%
Simplified78.4%
if -9.9499999999999999e-173 < z < -6.7999999999999994e-176Initial program 99.2%
associate-/l*52.4%
Simplified52.4%
Taylor expanded in x around 0 99.2%
remove-double-neg99.2%
distribute-neg-frac299.2%
*-commutative99.2%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.2%
associate-/l*52.4%
Simplified52.4%
Taylor expanded in z around 0 99.2%
associate-*r/99.2%
neg-mul-199.2%
distribute-rgt-neg-in99.2%
Simplified99.2%
Taylor expanded in x around 0 99.2%
mul-1-neg99.2%
associate-*l/100.0%
Simplified100.0%
if -6.7999999999999994e-176 < z < -3.49999999999999989e-186Initial program 100.0%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in z around 0 100.0%
associate-/l*100.0%
Simplified100.0%
if -3.49999999999999989e-186 < z < -8.60000000000000001e-187Initial program 68.2%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in x around 0 68.2%
remove-double-neg68.2%
distribute-neg-frac268.2%
*-commutative68.2%
associate-/l*99.5%
distribute-lft-neg-out99.5%
neg-sub099.5%
associate--r-99.5%
neg-sub099.5%
+-commutative99.5%
sub-neg99.5%
neg-sub099.5%
associate--r-99.5%
neg-sub099.5%
+-commutative99.5%
sub-neg99.5%
*-commutative99.5%
Simplified99.5%
Taylor expanded in t around 0 68.2%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in z around 0 68.2%
associate-*r/68.2%
neg-mul-168.2%
distribute-rgt-neg-in68.2%
Simplified68.2%
Taylor expanded in x around 0 68.2%
mul-1-neg68.2%
associate-*l/99.5%
Simplified99.5%
*-commutative99.5%
clear-num99.5%
un-div-inv100.0%
Applied egg-rr100.0%
if 3.4e13 < z Initial program 74.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in t around 0 53.9%
mul-1-neg53.9%
associate-/l*73.6%
distribute-rgt-neg-in73.6%
distribute-frac-neg73.6%
neg-sub073.6%
associate--r-73.6%
neg-sub073.6%
+-commutative73.6%
sub-neg73.6%
div-sub73.6%
*-inverses73.6%
Simplified73.6%
Final simplification76.4%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* x (/ (- y z) t))) (t_2 (* x (- 1.0 (/ y z)))))
(if (<= z -7.2e-109)
t_2
(if (<= z -9.95e-173)
t_1
(if (<= z -6.8e-176)
(* y (/ x (- z)))
(if (<= z -2.5e-183)
(* x (/ y t))
(if (<= z -8.6e-187)
(/ y (/ z (- x)))
(if (<= z 60000000000000.0) t_1 t_2))))))))
double code(double x, double y, double z, double t) {
double t_1 = x * ((y - z) / t);
double t_2 = x * (1.0 - (y / z));
double tmp;
if (z <= -7.2e-109) {
tmp = t_2;
} else if (z <= -9.95e-173) {
tmp = t_1;
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= -2.5e-183) {
tmp = x * (y / t);
} else if (z <= -8.6e-187) {
tmp = y / (z / -x);
} else if (z <= 60000000000000.0) {
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 = x * ((y - z) / t)
t_2 = x * (1.0d0 - (y / z))
if (z <= (-7.2d-109)) then
tmp = t_2
else if (z <= (-9.95d-173)) then
tmp = t_1
else if (z <= (-6.8d-176)) then
tmp = y * (x / -z)
else if (z <= (-2.5d-183)) then
tmp = x * (y / t)
else if (z <= (-8.6d-187)) then
tmp = y / (z / -x)
else if (z <= 60000000000000.0d0) 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 = x * ((y - z) / t);
double t_2 = x * (1.0 - (y / z));
double tmp;
if (z <= -7.2e-109) {
tmp = t_2;
} else if (z <= -9.95e-173) {
tmp = t_1;
} else if (z <= -6.8e-176) {
tmp = y * (x / -z);
} else if (z <= -2.5e-183) {
tmp = x * (y / t);
} else if (z <= -8.6e-187) {
tmp = y / (z / -x);
} else if (z <= 60000000000000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t): t_1 = x * ((y - z) / t) t_2 = x * (1.0 - (y / z)) tmp = 0 if z <= -7.2e-109: tmp = t_2 elif z <= -9.95e-173: tmp = t_1 elif z <= -6.8e-176: tmp = y * (x / -z) elif z <= -2.5e-183: tmp = x * (y / t) elif z <= -8.6e-187: tmp = y / (z / -x) elif z <= 60000000000000.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t) t_1 = Float64(x * Float64(Float64(y - z) / t)) t_2 = Float64(x * Float64(1.0 - Float64(y / z))) tmp = 0.0 if (z <= -7.2e-109) tmp = t_2; elseif (z <= -9.95e-173) tmp = t_1; elseif (z <= -6.8e-176) tmp = Float64(y * Float64(x / Float64(-z))); elseif (z <= -2.5e-183) tmp = Float64(x * Float64(y / t)); elseif (z <= -8.6e-187) tmp = Float64(y / Float64(z / Float64(-x))); elseif (z <= 60000000000000.0) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x * ((y - z) / t); t_2 = x * (1.0 - (y / z)); tmp = 0.0; if (z <= -7.2e-109) tmp = t_2; elseif (z <= -9.95e-173) tmp = t_1; elseif (z <= -6.8e-176) tmp = y * (x / -z); elseif (z <= -2.5e-183) tmp = x * (y / t); elseif (z <= -8.6e-187) tmp = y / (z / -x); elseif (z <= 60000000000000.0) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[(N[(y - z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7.2e-109], t$95$2, If[LessEqual[z, -9.95e-173], t$95$1, If[LessEqual[z, -6.8e-176], N[(y * N[(x / (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.5e-183], N[(x * N[(y / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -8.6e-187], N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 60000000000000.0], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{y - z}{t}\\
t_2 := x \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{if}\;z \leq -7.2 \cdot 10^{-109}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -9.95 \cdot 10^{-173}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -6.8 \cdot 10^{-176}:\\
\;\;\;\;y \cdot \frac{x}{-z}\\
\mathbf{elif}\;z \leq -2.5 \cdot 10^{-183}:\\
\;\;\;\;x \cdot \frac{y}{t}\\
\mathbf{elif}\;z \leq -8.6 \cdot 10^{-187}:\\
\;\;\;\;\frac{y}{\frac{z}{-x}}\\
\mathbf{elif}\;z \leq 60000000000000:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -7.2000000000000001e-109 or 6e13 < z Initial program 79.6%
associate-/l*99.4%
Simplified99.4%
Taylor expanded in t around 0 56.6%
mul-1-neg56.6%
associate-/l*73.6%
distribute-rgt-neg-in73.6%
distribute-frac-neg73.6%
neg-sub073.6%
associate--r-73.6%
neg-sub073.6%
+-commutative73.6%
sub-neg73.6%
div-sub73.6%
*-inverses73.6%
Simplified73.6%
if -7.2000000000000001e-109 < z < -9.9499999999999999e-173 or -8.60000000000000001e-187 < z < 6e13Initial program 92.4%
associate-/l*89.6%
Simplified89.6%
Taylor expanded in t around inf 79.3%
associate-/l*78.4%
Simplified78.4%
if -9.9499999999999999e-173 < z < -6.7999999999999994e-176Initial program 99.2%
associate-/l*52.4%
Simplified52.4%
Taylor expanded in x around 0 99.2%
remove-double-neg99.2%
distribute-neg-frac299.2%
*-commutative99.2%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.2%
associate-/l*52.4%
Simplified52.4%
Taylor expanded in z around 0 99.2%
associate-*r/99.2%
neg-mul-199.2%
distribute-rgt-neg-in99.2%
Simplified99.2%
Taylor expanded in x around 0 99.2%
mul-1-neg99.2%
associate-*l/100.0%
Simplified100.0%
if -6.7999999999999994e-176 < z < -2.5000000000000001e-183Initial program 100.0%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in z around 0 100.0%
associate-/l*100.0%
Simplified100.0%
if -2.5000000000000001e-183 < z < -8.60000000000000001e-187Initial program 76.1%
associate-/l*100.0%
Simplified100.0%
Taylor expanded in x around 0 76.1%
remove-double-neg76.1%
distribute-neg-frac276.1%
*-commutative76.1%
associate-/l*99.6%
distribute-lft-neg-out99.6%
neg-sub099.6%
associate--r-99.6%
neg-sub099.6%
+-commutative99.6%
sub-neg99.6%
neg-sub099.6%
associate--r-99.6%
neg-sub099.6%
+-commutative99.6%
sub-neg99.6%
*-commutative99.6%
Simplified99.6%
Taylor expanded in t around 0 76.1%
associate-/l*77.8%
Simplified77.8%
Taylor expanded in z around 0 76.1%
associate-*r/76.1%
neg-mul-176.1%
distribute-rgt-neg-in76.1%
Simplified76.1%
Taylor expanded in x around 0 76.1%
mul-1-neg76.1%
associate-*l/99.6%
Simplified99.6%
*-commutative99.6%
clear-num99.6%
un-div-inv100.0%
Applied egg-rr100.0%
Final simplification76.4%
(FPCore (x y z t)
:precision binary64
(if (<= z -2.2e+90)
x
(if (<= z -3.2e-14)
(* y (/ x t))
(if (<= z -3.9e-56)
(/ (* z x) z)
(if (<= z 42000000000000.0)
(/ y (/ t x))
(if (<= z 2e+73) x (if (<= z 1.45e+84) (/ y (/ z (- x))) x)))))))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -2.2e+90) {
tmp = x;
} else if (z <= -3.2e-14) {
tmp = y * (x / t);
} else if (z <= -3.9e-56) {
tmp = (z * x) / z;
} else if (z <= 42000000000000.0) {
tmp = y / (t / x);
} else if (z <= 2e+73) {
tmp = x;
} else if (z <= 1.45e+84) {
tmp = y / (z / -x);
} 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 <= (-2.2d+90)) then
tmp = x
else if (z <= (-3.2d-14)) then
tmp = y * (x / t)
else if (z <= (-3.9d-56)) then
tmp = (z * x) / z
else if (z <= 42000000000000.0d0) then
tmp = y / (t / x)
else if (z <= 2d+73) then
tmp = x
else if (z <= 1.45d+84) then
tmp = y / (z / -x)
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 <= -2.2e+90) {
tmp = x;
} else if (z <= -3.2e-14) {
tmp = y * (x / t);
} else if (z <= -3.9e-56) {
tmp = (z * x) / z;
} else if (z <= 42000000000000.0) {
tmp = y / (t / x);
} else if (z <= 2e+73) {
tmp = x;
} else if (z <= 1.45e+84) {
tmp = y / (z / -x);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -2.2e+90: tmp = x elif z <= -3.2e-14: tmp = y * (x / t) elif z <= -3.9e-56: tmp = (z * x) / z elif z <= 42000000000000.0: tmp = y / (t / x) elif z <= 2e+73: tmp = x elif z <= 1.45e+84: tmp = y / (z / -x) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -2.2e+90) tmp = x; elseif (z <= -3.2e-14) tmp = Float64(y * Float64(x / t)); elseif (z <= -3.9e-56) tmp = Float64(Float64(z * x) / z); elseif (z <= 42000000000000.0) tmp = Float64(y / Float64(t / x)); elseif (z <= 2e+73) tmp = x; elseif (z <= 1.45e+84) tmp = Float64(y / Float64(z / Float64(-x))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -2.2e+90) tmp = x; elseif (z <= -3.2e-14) tmp = y * (x / t); elseif (z <= -3.9e-56) tmp = (z * x) / z; elseif (z <= 42000000000000.0) tmp = y / (t / x); elseif (z <= 2e+73) tmp = x; elseif (z <= 1.45e+84) tmp = y / (z / -x); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -2.2e+90], x, If[LessEqual[z, -3.2e-14], N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.9e-56], N[(N[(z * x), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 42000000000000.0], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2e+73], x, If[LessEqual[z, 1.45e+84], N[(y / N[(z / (-x)), $MachinePrecision]), $MachinePrecision], x]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.2 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -3.2 \cdot 10^{-14}:\\
\;\;\;\;y \cdot \frac{x}{t}\\
\mathbf{elif}\;z \leq -3.9 \cdot 10^{-56}:\\
\;\;\;\;\frac{z \cdot x}{z}\\
\mathbf{elif}\;z \leq 42000000000000:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 2 \cdot 10^{+73}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.45 \cdot 10^{+84}:\\
\;\;\;\;\frac{y}{\frac{z}{-x}}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.1999999999999999e90 or 4.2e13 < z < 1.99999999999999997e73 or 1.44999999999999994e84 < z Initial program 75.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 67.7%
if -2.1999999999999999e90 < z < -3.2000000000000002e-14Initial program 90.1%
associate-/l*99.8%
Simplified99.8%
clear-num99.8%
un-div-inv99.8%
Applied egg-rr99.8%
Taylor expanded in z around 0 38.4%
associate-/r/38.4%
Applied egg-rr38.4%
if -3.2000000000000002e-14 < z < -3.9e-56Initial program 100.0%
remove-double-neg100.0%
distribute-lft-neg-out100.0%
distribute-neg-frac100.0%
distribute-neg-frac2100.0%
distribute-lft-neg-out100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in t around 0 66.8%
Taylor expanded in z around inf 55.8%
if -3.9e-56 < z < 4.2e13Initial program 92.4%
associate-/l*89.9%
Simplified89.9%
clear-num89.5%
un-div-inv89.5%
Applied egg-rr89.5%
Taylor expanded in z around 0 62.8%
associate-/r/63.9%
Applied egg-rr63.9%
*-commutative63.9%
clear-num63.9%
un-div-inv63.9%
Applied egg-rr63.9%
if 1.99999999999999997e73 < z < 1.44999999999999994e84Initial program 62.3%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in x around 0 62.3%
remove-double-neg62.3%
distribute-neg-frac262.3%
*-commutative62.3%
associate-/l*99.7%
distribute-lft-neg-out99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 23.7%
associate-/l*42.3%
Simplified42.3%
Taylor expanded in z around 0 33.0%
associate-*r/33.0%
neg-mul-133.0%
distribute-rgt-neg-in33.0%
Simplified33.0%
Taylor expanded in x around 0 33.0%
mul-1-neg33.0%
associate-*l/51.6%
Simplified51.6%
*-commutative51.6%
clear-num51.6%
un-div-inv51.6%
Applied egg-rr51.6%
Final simplification63.0%
(FPCore (x y z t)
:precision binary64
(if (<= z -1.26e+91)
x
(if (<= z -2.15e-13)
(* y (/ x t))
(if (<= z -3.1e-56)
(/ (* z x) z)
(if (<= z 4.4e+15)
(/ y (/ t x))
(if (<= z 1.3e+74) x (if (<= z 2.7e+84) (* y (/ x (- z))) x)))))))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -1.26e+91) {
tmp = x;
} else if (z <= -2.15e-13) {
tmp = y * (x / t);
} else if (z <= -3.1e-56) {
tmp = (z * x) / z;
} else if (z <= 4.4e+15) {
tmp = y / (t / x);
} else if (z <= 1.3e+74) {
tmp = x;
} else if (z <= 2.7e+84) {
tmp = y * (x / -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.26d+91)) then
tmp = x
else if (z <= (-2.15d-13)) then
tmp = y * (x / t)
else if (z <= (-3.1d-56)) then
tmp = (z * x) / z
else if (z <= 4.4d+15) then
tmp = y / (t / x)
else if (z <= 1.3d+74) then
tmp = x
else if (z <= 2.7d+84) then
tmp = y * (x / -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.26e+91) {
tmp = x;
} else if (z <= -2.15e-13) {
tmp = y * (x / t);
} else if (z <= -3.1e-56) {
tmp = (z * x) / z;
} else if (z <= 4.4e+15) {
tmp = y / (t / x);
} else if (z <= 1.3e+74) {
tmp = x;
} else if (z <= 2.7e+84) {
tmp = y * (x / -z);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -1.26e+91: tmp = x elif z <= -2.15e-13: tmp = y * (x / t) elif z <= -3.1e-56: tmp = (z * x) / z elif z <= 4.4e+15: tmp = y / (t / x) elif z <= 1.3e+74: tmp = x elif z <= 2.7e+84: tmp = y * (x / -z) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -1.26e+91) tmp = x; elseif (z <= -2.15e-13) tmp = Float64(y * Float64(x / t)); elseif (z <= -3.1e-56) tmp = Float64(Float64(z * x) / z); elseif (z <= 4.4e+15) tmp = Float64(y / Float64(t / x)); elseif (z <= 1.3e+74) tmp = x; elseif (z <= 2.7e+84) tmp = Float64(y * Float64(x / Float64(-z))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -1.26e+91) tmp = x; elseif (z <= -2.15e-13) tmp = y * (x / t); elseif (z <= -3.1e-56) tmp = (z * x) / z; elseif (z <= 4.4e+15) tmp = y / (t / x); elseif (z <= 1.3e+74) tmp = x; elseif (z <= 2.7e+84) tmp = y * (x / -z); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -1.26e+91], x, If[LessEqual[z, -2.15e-13], N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.1e-56], N[(N[(z * x), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 4.4e+15], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.3e+74], x, If[LessEqual[z, 2.7e+84], N[(y * N[(x / (-z)), $MachinePrecision]), $MachinePrecision], x]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.26 \cdot 10^{+91}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -2.15 \cdot 10^{-13}:\\
\;\;\;\;y \cdot \frac{x}{t}\\
\mathbf{elif}\;z \leq -3.1 \cdot 10^{-56}:\\
\;\;\;\;\frac{z \cdot x}{z}\\
\mathbf{elif}\;z \leq 4.4 \cdot 10^{+15}:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 1.3 \cdot 10^{+74}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 2.7 \cdot 10^{+84}:\\
\;\;\;\;y \cdot \frac{x}{-z}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -1.26e91 or 4.4e15 < z < 1.3e74 or 2.7e84 < z Initial program 75.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 67.7%
if -1.26e91 < z < -2.1499999999999999e-13Initial program 90.1%
associate-/l*99.8%
Simplified99.8%
clear-num99.8%
un-div-inv99.8%
Applied egg-rr99.8%
Taylor expanded in z around 0 38.4%
associate-/r/38.4%
Applied egg-rr38.4%
if -2.1499999999999999e-13 < z < -3.09999999999999987e-56Initial program 100.0%
remove-double-neg100.0%
distribute-lft-neg-out100.0%
distribute-neg-frac100.0%
distribute-neg-frac2100.0%
distribute-lft-neg-out100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in t around 0 66.8%
Taylor expanded in z around inf 55.8%
if -3.09999999999999987e-56 < z < 4.4e15Initial program 92.4%
associate-/l*89.9%
Simplified89.9%
clear-num89.5%
un-div-inv89.5%
Applied egg-rr89.5%
Taylor expanded in z around 0 62.8%
associate-/r/63.9%
Applied egg-rr63.9%
*-commutative63.9%
clear-num63.9%
un-div-inv63.9%
Applied egg-rr63.9%
if 1.3e74 < z < 2.7e84Initial program 62.3%
associate-/l*99.7%
Simplified99.7%
Taylor expanded in x around 0 62.3%
remove-double-neg62.3%
distribute-neg-frac262.3%
*-commutative62.3%
associate-/l*99.7%
distribute-lft-neg-out99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
neg-sub099.7%
associate--r-99.7%
neg-sub099.7%
+-commutative99.7%
sub-neg99.7%
*-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 23.7%
associate-/l*42.3%
Simplified42.3%
Taylor expanded in z around 0 33.0%
associate-*r/33.0%
neg-mul-133.0%
distribute-rgt-neg-in33.0%
Simplified33.0%
Taylor expanded in x around 0 33.0%
mul-1-neg33.0%
associate-*l/51.6%
Simplified51.6%
Final simplification63.0%
(FPCore (x y z t)
:precision binary64
(if (<= z -5.2e+90)
x
(if (or (<= z -9.2e-15)
(and (not (<= z -1.45e-55))
(or (<= z 52000000000000.0)
(and (not (<= z 8.5e+71)) (<= z 1.25e+84)))))
(* y (/ x t))
x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -5.2e+90) {
tmp = x;
} else if ((z <= -9.2e-15) || (!(z <= -1.45e-55) && ((z <= 52000000000000.0) || (!(z <= 8.5e+71) && (z <= 1.25e+84))))) {
tmp = y * (x / t);
} 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 <= (-5.2d+90)) then
tmp = x
else if ((z <= (-9.2d-15)) .or. (.not. (z <= (-1.45d-55))) .and. (z <= 52000000000000.0d0) .or. (.not. (z <= 8.5d+71)) .and. (z <= 1.25d+84)) then
tmp = y * (x / t)
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 <= -5.2e+90) {
tmp = x;
} else if ((z <= -9.2e-15) || (!(z <= -1.45e-55) && ((z <= 52000000000000.0) || (!(z <= 8.5e+71) && (z <= 1.25e+84))))) {
tmp = y * (x / t);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -5.2e+90: tmp = x elif (z <= -9.2e-15) or (not (z <= -1.45e-55) and ((z <= 52000000000000.0) or (not (z <= 8.5e+71) and (z <= 1.25e+84)))): tmp = y * (x / t) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -5.2e+90) tmp = x; elseif ((z <= -9.2e-15) || (!(z <= -1.45e-55) && ((z <= 52000000000000.0) || (!(z <= 8.5e+71) && (z <= 1.25e+84))))) tmp = Float64(y * Float64(x / t)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -5.2e+90) tmp = x; elseif ((z <= -9.2e-15) || (~((z <= -1.45e-55)) && ((z <= 52000000000000.0) || (~((z <= 8.5e+71)) && (z <= 1.25e+84))))) tmp = y * (x / t); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -5.2e+90], x, If[Or[LessEqual[z, -9.2e-15], And[N[Not[LessEqual[z, -1.45e-55]], $MachinePrecision], Or[LessEqual[z, 52000000000000.0], And[N[Not[LessEqual[z, 8.5e+71]], $MachinePrecision], LessEqual[z, 1.25e+84]]]]], N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.2 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -9.2 \cdot 10^{-15} \lor \neg \left(z \leq -1.45 \cdot 10^{-55}\right) \land \left(z \leq 52000000000000 \lor \neg \left(z \leq 8.5 \cdot 10^{+71}\right) \land z \leq 1.25 \cdot 10^{+84}\right):\\
\;\;\;\;y \cdot \frac{x}{t}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -5.1999999999999997e90 or -9.19999999999999961e-15 < z < -1.45e-55 or 5.2e13 < z < 8.4999999999999996e71 or 1.25e84 < z Initial program 77.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 66.8%
if -5.1999999999999997e90 < z < -9.19999999999999961e-15 or -1.45e-55 < z < 5.2e13 or 8.4999999999999996e71 < z < 1.25e84Initial program 91.0%
associate-/l*91.5%
Simplified91.5%
clear-num91.2%
un-div-inv91.2%
Applied egg-rr91.2%
Taylor expanded in z around 0 58.9%
associate-/r/59.8%
Applied egg-rr59.8%
Final simplification62.8%
(FPCore (x y z t)
:precision binary64
(if (<= z -2.5e+90)
x
(if (or (<= z -1.32e-14)
(and (not (<= z -2.6e-58))
(or (<= z 1.2e+14) (and (not (<= z 3.5e+74)) (<= z 4.2e+84)))))
(* x (/ y t))
x)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -2.5e+90) {
tmp = x;
} else if ((z <= -1.32e-14) || (!(z <= -2.6e-58) && ((z <= 1.2e+14) || (!(z <= 3.5e+74) && (z <= 4.2e+84))))) {
tmp = x * (y / t);
} 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 <= (-2.5d+90)) then
tmp = x
else if ((z <= (-1.32d-14)) .or. (.not. (z <= (-2.6d-58))) .and. (z <= 1.2d+14) .or. (.not. (z <= 3.5d+74)) .and. (z <= 4.2d+84)) then
tmp = x * (y / t)
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 <= -2.5e+90) {
tmp = x;
} else if ((z <= -1.32e-14) || (!(z <= -2.6e-58) && ((z <= 1.2e+14) || (!(z <= 3.5e+74) && (z <= 4.2e+84))))) {
tmp = x * (y / t);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -2.5e+90: tmp = x elif (z <= -1.32e-14) or (not (z <= -2.6e-58) and ((z <= 1.2e+14) or (not (z <= 3.5e+74) and (z <= 4.2e+84)))): tmp = x * (y / t) else: tmp = x return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -2.5e+90) tmp = x; elseif ((z <= -1.32e-14) || (!(z <= -2.6e-58) && ((z <= 1.2e+14) || (!(z <= 3.5e+74) && (z <= 4.2e+84))))) tmp = Float64(x * Float64(y / t)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -2.5e+90) tmp = x; elseif ((z <= -1.32e-14) || (~((z <= -2.6e-58)) && ((z <= 1.2e+14) || (~((z <= 3.5e+74)) && (z <= 4.2e+84))))) tmp = x * (y / t); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -2.5e+90], x, If[Or[LessEqual[z, -1.32e-14], And[N[Not[LessEqual[z, -2.6e-58]], $MachinePrecision], Or[LessEqual[z, 1.2e+14], And[N[Not[LessEqual[z, 3.5e+74]], $MachinePrecision], LessEqual[z, 4.2e+84]]]]], N[(x * N[(y / t), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.5 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -1.32 \cdot 10^{-14} \lor \neg \left(z \leq -2.6 \cdot 10^{-58}\right) \land \left(z \leq 1.2 \cdot 10^{+14} \lor \neg \left(z \leq 3.5 \cdot 10^{+74}\right) \land z \leq 4.2 \cdot 10^{+84}\right):\\
\;\;\;\;x \cdot \frac{y}{t}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.5000000000000002e90 or -1.32e-14 < z < -2.60000000000000007e-58 or 1.2e14 < z < 3.50000000000000014e74 or 4.20000000000000037e84 < z Initial program 77.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 66.8%
if -2.5000000000000002e90 < z < -1.32e-14 or -2.60000000000000007e-58 < z < 1.2e14 or 3.50000000000000014e74 < z < 4.20000000000000037e84Initial program 91.0%
associate-/l*91.5%
Simplified91.5%
Taylor expanded in z around 0 57.7%
associate-/l*58.9%
Simplified58.9%
Final simplification62.3%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* y (/ x t))))
(if (<= z -2.35e+90)
x
(if (<= z -1.2e-12)
t_1
(if (<= z -1.48e-55)
(/ (* z x) z)
(if (<= z 5e+14)
(/ y (/ t x))
(if (<= z 1.4e+74) x (if (<= z 1.1e+84) t_1 x))))))))
double code(double x, double y, double z, double t) {
double t_1 = y * (x / t);
double tmp;
if (z <= -2.35e+90) {
tmp = x;
} else if (z <= -1.2e-12) {
tmp = t_1;
} else if (z <= -1.48e-55) {
tmp = (z * x) / z;
} else if (z <= 5e+14) {
tmp = y / (t / x);
} else if (z <= 1.4e+74) {
tmp = x;
} else if (z <= 1.1e+84) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = y * (x / t)
if (z <= (-2.35d+90)) then
tmp = x
else if (z <= (-1.2d-12)) then
tmp = t_1
else if (z <= (-1.48d-55)) then
tmp = (z * x) / z
else if (z <= 5d+14) then
tmp = y / (t / x)
else if (z <= 1.4d+74) then
tmp = x
else if (z <= 1.1d+84) then
tmp = t_1
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = y * (x / t);
double tmp;
if (z <= -2.35e+90) {
tmp = x;
} else if (z <= -1.2e-12) {
tmp = t_1;
} else if (z <= -1.48e-55) {
tmp = (z * x) / z;
} else if (z <= 5e+14) {
tmp = y / (t / x);
} else if (z <= 1.4e+74) {
tmp = x;
} else if (z <= 1.1e+84) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): t_1 = y * (x / t) tmp = 0 if z <= -2.35e+90: tmp = x elif z <= -1.2e-12: tmp = t_1 elif z <= -1.48e-55: tmp = (z * x) / z elif z <= 5e+14: tmp = y / (t / x) elif z <= 1.4e+74: tmp = x elif z <= 1.1e+84: tmp = t_1 else: tmp = x return tmp
function code(x, y, z, t) t_1 = Float64(y * Float64(x / t)) tmp = 0.0 if (z <= -2.35e+90) tmp = x; elseif (z <= -1.2e-12) tmp = t_1; elseif (z <= -1.48e-55) tmp = Float64(Float64(z * x) / z); elseif (z <= 5e+14) tmp = Float64(y / Float64(t / x)); elseif (z <= 1.4e+74) tmp = x; elseif (z <= 1.1e+84) tmp = t_1; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = y * (x / t); tmp = 0.0; if (z <= -2.35e+90) tmp = x; elseif (z <= -1.2e-12) tmp = t_1; elseif (z <= -1.48e-55) tmp = (z * x) / z; elseif (z <= 5e+14) tmp = y / (t / x); elseif (z <= 1.4e+74) tmp = x; elseif (z <= 1.1e+84) tmp = t_1; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.35e+90], x, If[LessEqual[z, -1.2e-12], t$95$1, If[LessEqual[z, -1.48e-55], N[(N[(z * x), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 5e+14], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.4e+74], x, If[LessEqual[z, 1.1e+84], t$95$1, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{x}{t}\\
\mathbf{if}\;z \leq -2.35 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -1.2 \cdot 10^{-12}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.48 \cdot 10^{-55}:\\
\;\;\;\;\frac{z \cdot x}{z}\\
\mathbf{elif}\;z \leq 5 \cdot 10^{+14}:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 1.4 \cdot 10^{+74}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -2.3500000000000001e90 or 5e14 < z < 1.40000000000000001e74 or 1.0999999999999999e84 < z Initial program 75.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 67.7%
if -2.3500000000000001e90 < z < -1.19999999999999994e-12 or 1.40000000000000001e74 < z < 1.0999999999999999e84Initial program 84.3%
associate-/l*99.8%
Simplified99.8%
clear-num99.7%
un-div-inv99.7%
Applied egg-rr99.7%
Taylor expanded in z around 0 39.2%
associate-/r/39.3%
Applied egg-rr39.3%
if -1.19999999999999994e-12 < z < -1.4800000000000001e-55Initial program 100.0%
remove-double-neg100.0%
distribute-lft-neg-out100.0%
distribute-neg-frac100.0%
distribute-neg-frac2100.0%
distribute-lft-neg-out100.0%
distribute-rgt-neg-in100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in t around 0 66.8%
Taylor expanded in z around inf 55.8%
if -1.4800000000000001e-55 < z < 5e14Initial program 92.4%
associate-/l*89.9%
Simplified89.9%
clear-num89.5%
un-div-inv89.5%
Applied egg-rr89.5%
Taylor expanded in z around 0 62.8%
associate-/r/63.9%
Applied egg-rr63.9%
*-commutative63.9%
clear-num63.9%
un-div-inv63.9%
Applied egg-rr63.9%
Final simplification62.9%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* y (/ x t))))
(if (<= z -5.2e+90)
x
(if (<= z -3.2e-13)
t_1
(if (<= z -1.75e-55)
x
(if (<= z 1.1e+14)
(/ y (/ t x))
(if (<= z 2.4e+70) x (if (<= z 9.5e+83) t_1 x))))))))
double code(double x, double y, double z, double t) {
double t_1 = y * (x / t);
double tmp;
if (z <= -5.2e+90) {
tmp = x;
} else if (z <= -3.2e-13) {
tmp = t_1;
} else if (z <= -1.75e-55) {
tmp = x;
} else if (z <= 1.1e+14) {
tmp = y / (t / x);
} else if (z <= 2.4e+70) {
tmp = x;
} else if (z <= 9.5e+83) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = y * (x / t)
if (z <= (-5.2d+90)) then
tmp = x
else if (z <= (-3.2d-13)) then
tmp = t_1
else if (z <= (-1.75d-55)) then
tmp = x
else if (z <= 1.1d+14) then
tmp = y / (t / x)
else if (z <= 2.4d+70) then
tmp = x
else if (z <= 9.5d+83) then
tmp = t_1
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = y * (x / t);
double tmp;
if (z <= -5.2e+90) {
tmp = x;
} else if (z <= -3.2e-13) {
tmp = t_1;
} else if (z <= -1.75e-55) {
tmp = x;
} else if (z <= 1.1e+14) {
tmp = y / (t / x);
} else if (z <= 2.4e+70) {
tmp = x;
} else if (z <= 9.5e+83) {
tmp = t_1;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t): t_1 = y * (x / t) tmp = 0 if z <= -5.2e+90: tmp = x elif z <= -3.2e-13: tmp = t_1 elif z <= -1.75e-55: tmp = x elif z <= 1.1e+14: tmp = y / (t / x) elif z <= 2.4e+70: tmp = x elif z <= 9.5e+83: tmp = t_1 else: tmp = x return tmp
function code(x, y, z, t) t_1 = Float64(y * Float64(x / t)) tmp = 0.0 if (z <= -5.2e+90) tmp = x; elseif (z <= -3.2e-13) tmp = t_1; elseif (z <= -1.75e-55) tmp = x; elseif (z <= 1.1e+14) tmp = Float64(y / Float64(t / x)); elseif (z <= 2.4e+70) tmp = x; elseif (z <= 9.5e+83) tmp = t_1; else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = y * (x / t); tmp = 0.0; if (z <= -5.2e+90) tmp = x; elseif (z <= -3.2e-13) tmp = t_1; elseif (z <= -1.75e-55) tmp = x; elseif (z <= 1.1e+14) tmp = y / (t / x); elseif (z <= 2.4e+70) tmp = x; elseif (z <= 9.5e+83) tmp = t_1; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(y * N[(x / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.2e+90], x, If[LessEqual[z, -3.2e-13], t$95$1, If[LessEqual[z, -1.75e-55], x, If[LessEqual[z, 1.1e+14], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.4e+70], x, If[LessEqual[z, 9.5e+83], t$95$1, x]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{x}{t}\\
\mathbf{if}\;z \leq -5.2 \cdot 10^{+90}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq -3.2 \cdot 10^{-13}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.75 \cdot 10^{-55}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+14}:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{+70}:\\
\;\;\;\;x\\
\mathbf{elif}\;z \leq 9.5 \cdot 10^{+83}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if z < -5.1999999999999997e90 or -3.2e-13 < z < -1.75000000000000013e-55 or 1.1e14 < z < 2.39999999999999987e70 or 9.5000000000000002e83 < z Initial program 77.3%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in z around inf 66.8%
if -5.1999999999999997e90 < z < -3.2e-13 or 2.39999999999999987e70 < z < 9.5000000000000002e83Initial program 84.3%
associate-/l*99.8%
Simplified99.8%
clear-num99.7%
un-div-inv99.7%
Applied egg-rr99.7%
Taylor expanded in z around 0 39.2%
associate-/r/39.3%
Applied egg-rr39.3%
if -1.75000000000000013e-55 < z < 1.1e14Initial program 92.4%
associate-/l*89.9%
Simplified89.9%
clear-num89.5%
un-div-inv89.5%
Applied egg-rr89.5%
Taylor expanded in z around 0 62.8%
associate-/r/63.9%
Applied egg-rr63.9%
*-commutative63.9%
clear-num63.9%
un-div-inv63.9%
Applied egg-rr63.9%
Final simplification62.9%
(FPCore (x y z t)
:precision binary64
(if (<= z -8e-107)
(* x (/ (- z y) z))
(if (<= z -9.5e-172)
(/ (* x (- y z)) t)
(if (<= z -3e-180)
(/ (* x (- y)) z)
(if (<= z 130000000000.0)
(* (- y z) (/ x t))
(if (<= z 4e+203) (/ x (- 1.0 (/ t z))) (/ x (/ z (- z y)))))))))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= -8e-107) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = (x * (y - z)) / t;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 130000000000.0) {
tmp = (y - z) * (x / t);
} else if (z <= 4e+203) {
tmp = x / (1.0 - (t / z));
} else {
tmp = x / (z / (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 (z <= (-8d-107)) then
tmp = x * ((z - y) / z)
else if (z <= (-9.5d-172)) then
tmp = (x * (y - z)) / t
else if (z <= (-3d-180)) then
tmp = (x * -y) / z
else if (z <= 130000000000.0d0) then
tmp = (y - z) * (x / t)
else if (z <= 4d+203) then
tmp = x / (1.0d0 - (t / z))
else
tmp = x / (z / (z - y))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (z <= -8e-107) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = (x * (y - z)) / t;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 130000000000.0) {
tmp = (y - z) * (x / t);
} else if (z <= 4e+203) {
tmp = x / (1.0 - (t / z));
} else {
tmp = x / (z / (z - y));
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= -8e-107: tmp = x * ((z - y) / z) elif z <= -9.5e-172: tmp = (x * (y - z)) / t elif z <= -3e-180: tmp = (x * -y) / z elif z <= 130000000000.0: tmp = (y - z) * (x / t) elif z <= 4e+203: tmp = x / (1.0 - (t / z)) else: tmp = x / (z / (z - y)) return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= -8e-107) tmp = Float64(x * Float64(Float64(z - y) / z)); elseif (z <= -9.5e-172) tmp = Float64(Float64(x * Float64(y - z)) / t); elseif (z <= -3e-180) tmp = Float64(Float64(x * Float64(-y)) / z); elseif (z <= 130000000000.0) tmp = Float64(Float64(y - z) * Float64(x / t)); elseif (z <= 4e+203) tmp = Float64(x / Float64(1.0 - Float64(t / z))); else tmp = Float64(x / Float64(z / Float64(z - y))); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= -8e-107) tmp = x * ((z - y) / z); elseif (z <= -9.5e-172) tmp = (x * (y - z)) / t; elseif (z <= -3e-180) tmp = (x * -y) / z; elseif (z <= 130000000000.0) tmp = (y - z) * (x / t); elseif (z <= 4e+203) tmp = x / (1.0 - (t / z)); else tmp = x / (z / (z - y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, -8e-107], N[(x * N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.5e-172], N[(N[(x * N[(y - z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[z, -3e-180], N[(N[(x * (-y)), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 130000000000.0], N[(N[(y - z), $MachinePrecision] * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e+203], N[(x / N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(z / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8 \cdot 10^{-107}:\\
\;\;\;\;x \cdot \frac{z - y}{z}\\
\mathbf{elif}\;z \leq -9.5 \cdot 10^{-172}:\\
\;\;\;\;\frac{x \cdot \left(y - z\right)}{t}\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-180}:\\
\;\;\;\;\frac{x \cdot \left(-y\right)}{z}\\
\mathbf{elif}\;z \leq 130000000000:\\
\;\;\;\;\left(y - z\right) \cdot \frac{x}{t}\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+203}:\\
\;\;\;\;\frac{x}{1 - \frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\frac{z}{z - y}}\\
\end{array}
\end{array}
if z < -8e-107Initial program 84.1%
associate-/l*98.9%
Simplified98.9%
Taylor expanded in x around 0 84.1%
remove-double-neg84.1%
distribute-neg-frac284.1%
*-commutative84.1%
associate-/l*78.1%
distribute-lft-neg-out78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in t around 0 59.1%
associate-/l*73.6%
Simplified73.6%
if -8e-107 < z < -9.50000000000000053e-172Initial program 99.7%
associate-/l*82.3%
Simplified82.3%
Taylor expanded in t around inf 90.6%
if -9.50000000000000053e-172 < z < -3.0000000000000001e-180Initial program 99.8%
associate-/l*86.4%
Simplified86.4%
Taylor expanded in x around 0 99.8%
remove-double-neg99.8%
distribute-neg-frac299.8%
*-commutative99.8%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.8%
associate-/l*33.0%
Simplified33.0%
Taylor expanded in z around 0 99.8%
associate-*r/99.8%
neg-mul-199.8%
distribute-rgt-neg-in99.8%
Simplified99.8%
if -3.0000000000000001e-180 < z < 1.3e11Initial program 90.5%
associate-/l*90.6%
Simplified90.6%
clear-num90.5%
un-div-inv90.6%
Applied egg-rr90.6%
Taylor expanded in t around inf 77.2%
*-commutative77.2%
associate-/l*81.2%
Simplified81.2%
if 1.3e11 < z < 4e203Initial program 76.4%
associate-/l*99.7%
Simplified99.7%
clear-num99.6%
un-div-inv99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 78.5%
mul-1-neg78.5%
Simplified78.5%
Taylor expanded in x around 0 78.5%
if 4e203 < z Initial program 72.7%
associate-/l*99.9%
Simplified99.9%
clear-num99.9%
un-div-inv99.9%
Applied egg-rr99.9%
Taylor expanded in t around 0 94.0%
neg-mul-194.0%
distribute-neg-frac294.0%
neg-sub094.0%
associate-+l-94.0%
neg-sub094.0%
+-commutative94.0%
sub-neg94.0%
Simplified94.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* (- y z) (/ x t))))
(if (<= z -1.05e-106)
(* x (/ (- z y) z))
(if (<= z -9.5e-172)
t_1
(if (<= z -3e-180)
(/ (* x (- y)) z)
(if (<= z 330000000000.0)
t_1
(if (<= z 7e+202) (/ x (- 1.0 (/ t z))) (/ x (/ z (- z y))))))))))
double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 330000000000.0) {
tmp = t_1;
} else if (z <= 7e+202) {
tmp = x / (1.0 - (t / z));
} else {
tmp = x / (z / (z - y));
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = (y - z) * (x / t)
if (z <= (-1.05d-106)) then
tmp = x * ((z - y) / z)
else if (z <= (-9.5d-172)) then
tmp = t_1
else if (z <= (-3d-180)) then
tmp = (x * -y) / z
else if (z <= 330000000000.0d0) then
tmp = t_1
else if (z <= 7d+202) then
tmp = x / (1.0d0 - (t / z))
else
tmp = x / (z / (z - y))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 330000000000.0) {
tmp = t_1;
} else if (z <= 7e+202) {
tmp = x / (1.0 - (t / z));
} else {
tmp = x / (z / (z - y));
}
return tmp;
}
def code(x, y, z, t): t_1 = (y - z) * (x / t) tmp = 0 if z <= -1.05e-106: tmp = x * ((z - y) / z) elif z <= -9.5e-172: tmp = t_1 elif z <= -3e-180: tmp = (x * -y) / z elif z <= 330000000000.0: tmp = t_1 elif z <= 7e+202: tmp = x / (1.0 - (t / z)) else: tmp = x / (z / (z - y)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(y - z) * Float64(x / t)) tmp = 0.0 if (z <= -1.05e-106) tmp = Float64(x * Float64(Float64(z - y) / z)); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = Float64(Float64(x * Float64(-y)) / z); elseif (z <= 330000000000.0) tmp = t_1; elseif (z <= 7e+202) tmp = Float64(x / Float64(1.0 - Float64(t / z))); else tmp = Float64(x / Float64(z / Float64(z - y))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (y - z) * (x / t); tmp = 0.0; if (z <= -1.05e-106) tmp = x * ((z - y) / z); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = (x * -y) / z; elseif (z <= 330000000000.0) tmp = t_1; elseif (z <= 7e+202) tmp = x / (1.0 - (t / z)); else tmp = x / (z / (z - y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(x / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.05e-106], N[(x * N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.5e-172], t$95$1, If[LessEqual[z, -3e-180], N[(N[(x * (-y)), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 330000000000.0], t$95$1, If[LessEqual[z, 7e+202], N[(x / N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(z / N[(z - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{x}{t}\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{-106}:\\
\;\;\;\;x \cdot \frac{z - y}{z}\\
\mathbf{elif}\;z \leq -9.5 \cdot 10^{-172}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-180}:\\
\;\;\;\;\frac{x \cdot \left(-y\right)}{z}\\
\mathbf{elif}\;z \leq 330000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 7 \cdot 10^{+202}:\\
\;\;\;\;\frac{x}{1 - \frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\frac{z}{z - y}}\\
\end{array}
\end{array}
if z < -1.05000000000000002e-106Initial program 84.1%
associate-/l*98.9%
Simplified98.9%
Taylor expanded in x around 0 84.1%
remove-double-neg84.1%
distribute-neg-frac284.1%
*-commutative84.1%
associate-/l*78.1%
distribute-lft-neg-out78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in t around 0 59.1%
associate-/l*73.6%
Simplified73.6%
if -1.05000000000000002e-106 < z < -9.50000000000000053e-172 or -3.0000000000000001e-180 < z < 3.3e11Initial program 91.5%
associate-/l*89.7%
Simplified89.7%
clear-num89.7%
un-div-inv89.7%
Applied egg-rr89.7%
Taylor expanded in t around inf 78.6%
*-commutative78.6%
associate-/l*82.2%
Simplified82.2%
if -9.50000000000000053e-172 < z < -3.0000000000000001e-180Initial program 99.8%
associate-/l*86.4%
Simplified86.4%
Taylor expanded in x around 0 99.8%
remove-double-neg99.8%
distribute-neg-frac299.8%
*-commutative99.8%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.8%
associate-/l*33.0%
Simplified33.0%
Taylor expanded in z around 0 99.8%
associate-*r/99.8%
neg-mul-199.8%
distribute-rgt-neg-in99.8%
Simplified99.8%
if 3.3e11 < z < 6.99999999999999975e202Initial program 76.4%
associate-/l*99.7%
Simplified99.7%
clear-num99.6%
un-div-inv99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 78.5%
mul-1-neg78.5%
Simplified78.5%
Taylor expanded in x around 0 78.5%
if 6.99999999999999975e202 < z Initial program 72.7%
associate-/l*99.9%
Simplified99.9%
clear-num99.9%
un-div-inv99.9%
Applied egg-rr99.9%
Taylor expanded in t around 0 94.0%
neg-mul-194.0%
distribute-neg-frac294.0%
neg-sub094.0%
associate-+l-94.0%
neg-sub094.0%
+-commutative94.0%
sub-neg94.0%
Simplified94.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* (- y z) (/ x t))))
(if (<= z -1.05e-106)
(* x (/ (- z y) z))
(if (<= z -9.5e-172)
t_1
(if (<= z -3e-180)
(/ (* x (- y)) z)
(if (<= z 90000000000.0)
t_1
(if (<= z 6.6e+202)
(/ x (- 1.0 (/ t z)))
(* x (- 1.0 (/ y z))))))))))
double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 90000000000.0) {
tmp = t_1;
} else if (z <= 6.6e+202) {
tmp = x / (1.0 - (t / z));
} else {
tmp = x * (1.0 - (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) :: t_1
real(8) :: tmp
t_1 = (y - z) * (x / t)
if (z <= (-1.05d-106)) then
tmp = x * ((z - y) / z)
else if (z <= (-9.5d-172)) then
tmp = t_1
else if (z <= (-3d-180)) then
tmp = (x * -y) / z
else if (z <= 90000000000.0d0) then
tmp = t_1
else if (z <= 6.6d+202) then
tmp = x / (1.0d0 - (t / z))
else
tmp = x * (1.0d0 - (y / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 90000000000.0) {
tmp = t_1;
} else if (z <= 6.6e+202) {
tmp = x / (1.0 - (t / z));
} else {
tmp = x * (1.0 - (y / z));
}
return tmp;
}
def code(x, y, z, t): t_1 = (y - z) * (x / t) tmp = 0 if z <= -1.05e-106: tmp = x * ((z - y) / z) elif z <= -9.5e-172: tmp = t_1 elif z <= -3e-180: tmp = (x * -y) / z elif z <= 90000000000.0: tmp = t_1 elif z <= 6.6e+202: tmp = x / (1.0 - (t / z)) else: tmp = x * (1.0 - (y / z)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(y - z) * Float64(x / t)) tmp = 0.0 if (z <= -1.05e-106) tmp = Float64(x * Float64(Float64(z - y) / z)); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = Float64(Float64(x * Float64(-y)) / z); elseif (z <= 90000000000.0) tmp = t_1; elseif (z <= 6.6e+202) tmp = Float64(x / Float64(1.0 - Float64(t / z))); else tmp = Float64(x * Float64(1.0 - Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (y - z) * (x / t); tmp = 0.0; if (z <= -1.05e-106) tmp = x * ((z - y) / z); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = (x * -y) / z; elseif (z <= 90000000000.0) tmp = t_1; elseif (z <= 6.6e+202) tmp = x / (1.0 - (t / z)); else tmp = x * (1.0 - (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(x / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.05e-106], N[(x * N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.5e-172], t$95$1, If[LessEqual[z, -3e-180], N[(N[(x * (-y)), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 90000000000.0], t$95$1, If[LessEqual[z, 6.6e+202], N[(x / N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{x}{t}\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{-106}:\\
\;\;\;\;x \cdot \frac{z - y}{z}\\
\mathbf{elif}\;z \leq -9.5 \cdot 10^{-172}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-180}:\\
\;\;\;\;\frac{x \cdot \left(-y\right)}{z}\\
\mathbf{elif}\;z \leq 90000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 6.6 \cdot 10^{+202}:\\
\;\;\;\;\frac{x}{1 - \frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{z}\right)\\
\end{array}
\end{array}
if z < -1.05000000000000002e-106Initial program 84.1%
associate-/l*98.9%
Simplified98.9%
Taylor expanded in x around 0 84.1%
remove-double-neg84.1%
distribute-neg-frac284.1%
*-commutative84.1%
associate-/l*78.1%
distribute-lft-neg-out78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in t around 0 59.1%
associate-/l*73.6%
Simplified73.6%
if -1.05000000000000002e-106 < z < -9.50000000000000053e-172 or -3.0000000000000001e-180 < z < 9e10Initial program 91.5%
associate-/l*89.7%
Simplified89.7%
clear-num89.7%
un-div-inv89.7%
Applied egg-rr89.7%
Taylor expanded in t around inf 78.6%
*-commutative78.6%
associate-/l*82.2%
Simplified82.2%
if -9.50000000000000053e-172 < z < -3.0000000000000001e-180Initial program 99.8%
associate-/l*86.4%
Simplified86.4%
Taylor expanded in x around 0 99.8%
remove-double-neg99.8%
distribute-neg-frac299.8%
*-commutative99.8%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.8%
associate-/l*33.0%
Simplified33.0%
Taylor expanded in z around 0 99.8%
associate-*r/99.8%
neg-mul-199.8%
distribute-rgt-neg-in99.8%
Simplified99.8%
if 9e10 < z < 6.5999999999999998e202Initial program 76.4%
associate-/l*99.7%
Simplified99.7%
clear-num99.6%
un-div-inv99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 78.5%
mul-1-neg78.5%
Simplified78.5%
Taylor expanded in x around 0 78.5%
if 6.5999999999999998e202 < z Initial program 72.7%
associate-/l*99.9%
Simplified99.9%
Taylor expanded in t around 0 66.8%
mul-1-neg66.8%
associate-/l*94.0%
distribute-rgt-neg-in94.0%
distribute-frac-neg94.0%
neg-sub094.0%
associate--r-94.0%
neg-sub094.0%
+-commutative94.0%
sub-neg94.0%
div-sub94.0%
*-inverses94.0%
Simplified94.0%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* (- y z) (/ x t))))
(if (<= z -1.05e-106)
(* x (/ (- z y) z))
(if (<= z -9.5e-172)
t_1
(if (<= z -3e-180)
(/ (* x (- y)) z)
(if (<= z 8.4e-52) t_1 (* x (- 1.0 (/ y z)))))))))
double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 8.4e-52) {
tmp = t_1;
} else {
tmp = x * (1.0 - (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) :: t_1
real(8) :: tmp
t_1 = (y - z) * (x / t)
if (z <= (-1.05d-106)) then
tmp = x * ((z - y) / z)
else if (z <= (-9.5d-172)) then
tmp = t_1
else if (z <= (-3d-180)) then
tmp = (x * -y) / z
else if (z <= 8.4d-52) then
tmp = t_1
else
tmp = x * (1.0d0 - (y / z))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (y - z) * (x / t);
double tmp;
if (z <= -1.05e-106) {
tmp = x * ((z - y) / z);
} else if (z <= -9.5e-172) {
tmp = t_1;
} else if (z <= -3e-180) {
tmp = (x * -y) / z;
} else if (z <= 8.4e-52) {
tmp = t_1;
} else {
tmp = x * (1.0 - (y / z));
}
return tmp;
}
def code(x, y, z, t): t_1 = (y - z) * (x / t) tmp = 0 if z <= -1.05e-106: tmp = x * ((z - y) / z) elif z <= -9.5e-172: tmp = t_1 elif z <= -3e-180: tmp = (x * -y) / z elif z <= 8.4e-52: tmp = t_1 else: tmp = x * (1.0 - (y / z)) return tmp
function code(x, y, z, t) t_1 = Float64(Float64(y - z) * Float64(x / t)) tmp = 0.0 if (z <= -1.05e-106) tmp = Float64(x * Float64(Float64(z - y) / z)); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = Float64(Float64(x * Float64(-y)) / z); elseif (z <= 8.4e-52) tmp = t_1; else tmp = Float64(x * Float64(1.0 - Float64(y / z))); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (y - z) * (x / t); tmp = 0.0; if (z <= -1.05e-106) tmp = x * ((z - y) / z); elseif (z <= -9.5e-172) tmp = t_1; elseif (z <= -3e-180) tmp = (x * -y) / z; elseif (z <= 8.4e-52) tmp = t_1; else tmp = x * (1.0 - (y / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(x / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.05e-106], N[(x * N[(N[(z - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.5e-172], t$95$1, If[LessEqual[z, -3e-180], N[(N[(x * (-y)), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 8.4e-52], t$95$1, N[(x * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y - z\right) \cdot \frac{x}{t}\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{-106}:\\
\;\;\;\;x \cdot \frac{z - y}{z}\\
\mathbf{elif}\;z \leq -9.5 \cdot 10^{-172}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3 \cdot 10^{-180}:\\
\;\;\;\;\frac{x \cdot \left(-y\right)}{z}\\
\mathbf{elif}\;z \leq 8.4 \cdot 10^{-52}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(1 - \frac{y}{z}\right)\\
\end{array}
\end{array}
if z < -1.05000000000000002e-106Initial program 84.1%
associate-/l*98.9%
Simplified98.9%
Taylor expanded in x around 0 84.1%
remove-double-neg84.1%
distribute-neg-frac284.1%
*-commutative84.1%
associate-/l*78.1%
distribute-lft-neg-out78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
neg-sub078.1%
associate--r-78.1%
neg-sub078.1%
+-commutative78.1%
sub-neg78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in t around 0 59.1%
associate-/l*73.6%
Simplified73.6%
if -1.05000000000000002e-106 < z < -9.50000000000000053e-172 or -3.0000000000000001e-180 < z < 8.3999999999999995e-52Initial program 89.9%
associate-/l*87.8%
Simplified87.8%
clear-num87.7%
un-div-inv87.7%
Applied egg-rr87.7%
Taylor expanded in t around inf 81.2%
*-commutative81.2%
associate-/l*87.6%
Simplified87.6%
if -9.50000000000000053e-172 < z < -3.0000000000000001e-180Initial program 99.8%
associate-/l*86.4%
Simplified86.4%
Taylor expanded in x around 0 99.8%
remove-double-neg99.8%
distribute-neg-frac299.8%
*-commutative99.8%
associate-/l*100.0%
distribute-lft-neg-out100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
neg-sub0100.0%
associate--r-100.0%
neg-sub0100.0%
+-commutative100.0%
sub-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around 0 99.8%
associate-/l*33.0%
Simplified33.0%
Taylor expanded in z around 0 99.8%
associate-*r/99.8%
neg-mul-199.8%
distribute-rgt-neg-in99.8%
Simplified99.8%
if 8.3999999999999995e-52 < z Initial program 79.8%
associate-/l*99.8%
Simplified99.8%
Taylor expanded in t around 0 52.4%
mul-1-neg52.4%
associate-/l*68.1%
distribute-rgt-neg-in68.1%
distribute-frac-neg68.1%
neg-sub068.1%
associate--r-68.1%
neg-sub068.1%
+-commutative68.1%
sub-neg68.1%
div-sub68.1%
*-inverses68.1%
Simplified68.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (* x (- 1.0 (/ y z)))))
(if (<= z -2.5e-72)
t_1
(if (<= z -4.2e-158)
(/ (* z (- x)) t)
(if (<= z 2.8e-242)
(/ y (/ t x))
(if (<= z 4.4e-9) (/ x (/ t y)) t_1))))))
double code(double x, double y, double z, double t) {
double t_1 = x * (1.0 - (y / z));
double tmp;
if (z <= -2.5e-72) {
tmp = t_1;
} else if (z <= -4.2e-158) {
tmp = (z * -x) / t;
} else if (z <= 2.8e-242) {
tmp = y / (t / x);
} else if (z <= 4.4e-9) {
tmp = x / (t / y);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = x * (1.0d0 - (y / z))
if (z <= (-2.5d-72)) then
tmp = t_1
else if (z <= (-4.2d-158)) then
tmp = (z * -x) / t
else if (z <= 2.8d-242) then
tmp = y / (t / x)
else if (z <= 4.4d-9) then
tmp = x / (t / y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = x * (1.0 - (y / z));
double tmp;
if (z <= -2.5e-72) {
tmp = t_1;
} else if (z <= -4.2e-158) {
tmp = (z * -x) / t;
} else if (z <= 2.8e-242) {
tmp = y / (t / x);
} else if (z <= 4.4e-9) {
tmp = x / (t / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = x * (1.0 - (y / z)) tmp = 0 if z <= -2.5e-72: tmp = t_1 elif z <= -4.2e-158: tmp = (z * -x) / t elif z <= 2.8e-242: tmp = y / (t / x) elif z <= 4.4e-9: tmp = x / (t / y) else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(x * Float64(1.0 - Float64(y / z))) tmp = 0.0 if (z <= -2.5e-72) tmp = t_1; elseif (z <= -4.2e-158) tmp = Float64(Float64(z * Float64(-x)) / t); elseif (z <= 2.8e-242) tmp = Float64(y / Float64(t / x)); elseif (z <= 4.4e-9) tmp = Float64(x / Float64(t / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = x * (1.0 - (y / z)); tmp = 0.0; if (z <= -2.5e-72) tmp = t_1; elseif (z <= -4.2e-158) tmp = (z * -x) / t; elseif (z <= 2.8e-242) tmp = y / (t / x); elseif (z <= 4.4e-9) tmp = x / (t / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(x * N[(1.0 - N[(y / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.5e-72], t$95$1, If[LessEqual[z, -4.2e-158], N[(N[(z * (-x)), $MachinePrecision] / t), $MachinePrecision], If[LessEqual[z, 2.8e-242], N[(y / N[(t / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.4e-9], N[(x / N[(t / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(1 - \frac{y}{z}\right)\\
\mathbf{if}\;z \leq -2.5 \cdot 10^{-72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -4.2 \cdot 10^{-158}:\\
\;\;\;\;\frac{z \cdot \left(-x\right)}{t}\\
\mathbf{elif}\;z \leq 2.8 \cdot 10^{-242}:\\
\;\;\;\;\frac{y}{\frac{t}{x}}\\
\mathbf{elif}\;z \leq 4.4 \cdot 10^{-9}:\\
\;\;\;\;\frac{x}{\frac{t}{y}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.4999999999999998e-72 or 4.3999999999999997e-9 < z Initial program 79.8%
associate-/l*99.3%
Simplified99.3%
Taylor expanded in t around 0 56.1%
mul-1-neg56.1%
associate-/l*72.9%
distribute-rgt-neg-in72.9%
distribute-frac-neg72.9%
neg-sub072.9%
associate--r-72.9%
neg-sub072.9%
+-commutative72.9%
sub-neg72.9%
div-sub72.9%
*-inverses72.9%
Simplified72.9%
if -2.4999999999999998e-72 < z < -4.19999999999999983e-158Initial program 99.8%
associate-/l*93.0%
Simplified93.0%
Taylor expanded in t around inf 72.0%
associate-/l*65.2%
Simplified65.2%
Taylor expanded in y around 0 60.0%
associate-*r/60.0%
neg-mul-160.0%
*-commutative60.0%
distribute-lft-neg-in60.0%
Simplified60.0%
if -4.19999999999999983e-158 < z < 2.79999999999999983e-242Initial program 89.0%
associate-/l*82.4%
Simplified82.4%
clear-num82.4%
un-div-inv82.3%
Applied egg-rr82.3%
Taylor expanded in z around 0 75.0%
associate-/r/84.4%
Applied egg-rr84.4%
*-commutative84.4%
clear-num84.3%
un-div-inv84.4%
Applied egg-rr84.4%
if 2.79999999999999983e-242 < z < 4.3999999999999997e-9Initial program 92.4%
associate-/l*94.3%
Simplified94.3%
clear-num94.2%
un-div-inv94.3%
Applied egg-rr94.3%
Taylor expanded in z around 0 65.7%
Final simplification72.6%
(FPCore (x y z t) :precision binary64 (if (or (<= z -8.6e+81) (not (<= z 3.8e-90))) (* x (/ (- y z) (- t z))) (* (/ x (- z t)) (- z y))))
double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -8.6e+81) || !(z <= 3.8e-90)) {
tmp = x * ((y - z) / (t - z));
} else {
tmp = (x / (z - t)) * (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 ((z <= (-8.6d+81)) .or. (.not. (z <= 3.8d-90))) then
tmp = x * ((y - z) / (t - z))
else
tmp = (x / (z - t)) * (z - y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -8.6e+81) || !(z <= 3.8e-90)) {
tmp = x * ((y - z) / (t - z));
} else {
tmp = (x / (z - t)) * (z - y);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z <= -8.6e+81) or not (z <= 3.8e-90): tmp = x * ((y - z) / (t - z)) else: tmp = (x / (z - t)) * (z - y) return tmp
function code(x, y, z, t) tmp = 0.0 if ((z <= -8.6e+81) || !(z <= 3.8e-90)) tmp = Float64(x * Float64(Float64(y - z) / Float64(t - z))); else tmp = Float64(Float64(x / Float64(z - t)) * Float64(z - y)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z <= -8.6e+81) || ~((z <= 3.8e-90))) tmp = x * ((y - z) / (t - z)); else tmp = (x / (z - t)) * (z - y); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[z, -8.6e+81], N[Not[LessEqual[z, 3.8e-90]], $MachinePrecision]], N[(x * N[(N[(y - z), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(z - t), $MachinePrecision]), $MachinePrecision] * N[(z - y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.6 \cdot 10^{+81} \lor \neg \left(z \leq 3.8 \cdot 10^{-90}\right):\\
\;\;\;\;x \cdot \frac{y - z}{t - z}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{z - t} \cdot \left(z - y\right)\\
\end{array}
\end{array}
if z < -8.6000000000000003e81 or 3.8e-90 < z Initial program 79.8%
associate-/l*99.8%
Simplified99.8%
if -8.6000000000000003e81 < z < 3.8e-90Initial program 90.9%
associate-/l*89.9%
Simplified89.9%
Taylor expanded in x around 0 90.9%
remove-double-neg90.9%
distribute-neg-frac290.9%
*-commutative90.9%
associate-/l*97.4%
distribute-lft-neg-out97.4%
neg-sub097.4%
associate--r-97.4%
neg-sub097.4%
+-commutative97.4%
sub-neg97.4%
neg-sub097.4%
associate--r-97.4%
neg-sub097.4%
+-commutative97.4%
sub-neg97.4%
*-commutative97.4%
Simplified97.4%
Final simplification98.7%
(FPCore (x y z t) :precision binary64 (* x (/ (- y z) (- t z))))
double code(double x, double y, double z, double t) {
return x * ((y - z) / (t - z));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x * ((y - z) / (t - z))
end function
public static double code(double x, double y, double z, double t) {
return x * ((y - z) / (t - z));
}
def code(x, y, z, t): return x * ((y - z) / (t - z))
function code(x, y, z, t) return Float64(x * Float64(Float64(y - z) / Float64(t - z))) end
function tmp = code(x, y, z, t) tmp = x * ((y - z) / (t - z)); end
code[x_, y_, z_, t_] := N[(x * N[(N[(y - z), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \frac{y - z}{t - z}
\end{array}
Initial program 85.0%
associate-/l*95.1%
Simplified95.1%
(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 85.0%
associate-/l*95.1%
Simplified95.1%
Taylor expanded in z around inf 33.9%
(FPCore (x y z t) :precision binary64 (/ x (/ (- t z) (- y z))))
double code(double x, double y, double z, double t) {
return x / ((t - z) / (y - z));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = x / ((t - z) / (y - z))
end function
public static double code(double x, double y, double z, double t) {
return x / ((t - z) / (y - z));
}
def code(x, y, z, t): return x / ((t - z) / (y - z))
function code(x, y, z, t) return Float64(x / Float64(Float64(t - z) / Float64(y - z))) end
function tmp = code(x, y, z, t) tmp = x / ((t - z) / (y - z)); end
code[x_, y_, z_, t_] := N[(x / N[(N[(t - z), $MachinePrecision] / N[(y - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{\frac{t - z}{y - z}}
\end{array}
herbie shell --seed 2024105
(FPCore (x y z t)
:name "Graphics.Rendering.Chart.Plot.AreaSpots:renderAreaSpots4D from Chart-1.5.3"
:precision binary64
:alt
(/ x (/ (- t z) (- y z)))
(/ (* x (- y z)) (- t z)))