
(FPCore (x y z t) :precision binary64 (+ (/ x y) (/ (+ 2.0 (* (* z 2.0) (- 1.0 t))) (* t z))))
double code(double x, double y, double z, double t) {
return (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (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) + ((2.0d0 + ((z * 2.0d0) * (1.0d0 - t))) / (t * z))
end function
public static double code(double x, double y, double z, double t) {
return (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (t * z));
}
def code(x, y, z, t): return (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (t * z))
function code(x, y, z, t) return Float64(Float64(x / y) + Float64(Float64(2.0 + Float64(Float64(z * 2.0) * Float64(1.0 - t))) / Float64(t * z))) end
function tmp = code(x, y, z, t) tmp = (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (t * z)); end
code[x_, y_, z_, t_] := N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 + N[(N[(z * 2.0), $MachinePrecision] * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y} + \frac{2 + \left(z \cdot 2\right) \cdot \left(1 - t\right)}{t \cdot z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (+ (/ x y) (/ (+ 2.0 (* (* z 2.0) (- 1.0 t))) (* t z))))
double code(double x, double y, double z, double t) {
return (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (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) + ((2.0d0 + ((z * 2.0d0) * (1.0d0 - t))) / (t * z))
end function
public static double code(double x, double y, double z, double t) {
return (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (t * z));
}
def code(x, y, z, t): return (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (t * z))
function code(x, y, z, t) return Float64(Float64(x / y) + Float64(Float64(2.0 + Float64(Float64(z * 2.0) * Float64(1.0 - t))) / Float64(t * z))) end
function tmp = code(x, y, z, t) tmp = (x / y) + ((2.0 + ((z * 2.0) * (1.0 - t))) / (t * z)); end
code[x_, y_, z_, t_] := N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 + N[(N[(z * 2.0), $MachinePrecision] * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y} + \frac{2 + \left(z \cdot 2\right) \cdot \left(1 - t\right)}{t \cdot z}
\end{array}
(FPCore (x y z t) :precision binary64 (if (<= (+ (/ x y) (/ (+ 2.0 (* (* 2.0 z) (- 1.0 t))) (* z t))) INFINITY) (fma (fma z (- 1.0 t) 1.0) (/ 2.0 (* z t)) (/ x y)) (- (/ x y) 2.0)))
double code(double x, double y, double z, double t) {
double tmp;
if (((x / y) + ((2.0 + ((2.0 * z) * (1.0 - t))) / (z * t))) <= ((double) INFINITY)) {
tmp = fma(fma(z, (1.0 - t), 1.0), (2.0 / (z * t)), (x / y));
} else {
tmp = (x / y) - 2.0;
}
return tmp;
}
function code(x, y, z, t) tmp = 0.0 if (Float64(Float64(x / y) + Float64(Float64(2.0 + Float64(Float64(2.0 * z) * Float64(1.0 - t))) / Float64(z * t))) <= Inf) tmp = fma(fma(z, Float64(1.0 - t), 1.0), Float64(2.0 / Float64(z * t)), Float64(x / y)); else tmp = Float64(Float64(x / y) - 2.0); end return tmp end
code[x_, y_, z_, t_] := If[LessEqual[N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 + N[(N[(2.0 * z), $MachinePrecision] * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(z * N[(1.0 - t), $MachinePrecision] + 1.0), $MachinePrecision] * N[(2.0 / N[(z * t), $MachinePrecision]), $MachinePrecision] + N[(x / y), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] - 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} + \frac{2 + \left(2 \cdot z\right) \cdot \left(1 - t\right)}{z \cdot t} \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(z, 1 - t, 1\right), \frac{2}{z \cdot t}, \frac{x}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} - 2\\
\end{array}
\end{array}
if (+.f64 (/.f64 x y) (/.f64 (+.f64 #s(literal 2 binary64) (*.f64 (*.f64 z #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) t))) (*.f64 t z))) < +inf.0Initial program 99.3%
+-commutative99.3%
remove-double-neg99.3%
distribute-frac-neg99.3%
unsub-neg99.3%
*-commutative99.3%
associate-*r*99.3%
distribute-rgt1-in99.3%
associate-/l*99.7%
fma-neg99.7%
*-commutative99.7%
fma-define99.7%
*-commutative99.7%
distribute-frac-neg99.7%
remove-double-neg99.7%
Simplified99.7%
if +inf.0 < (+.f64 (/.f64 x y) (/.f64 (+.f64 #s(literal 2 binary64) (*.f64 (*.f64 z #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) t))) (*.f64 t z))) Initial program 0.0%
Taylor expanded in t around inf 100.0%
Final simplification99.8%
(FPCore (x y z t) :precision binary64 (let* ((t_1 (+ (/ x y) (/ (+ 2.0 (* (* 2.0 z) (- 1.0 t))) (* z t))))) (if (<= t_1 INFINITY) t_1 (- (/ x y) 2.0))))
double code(double x, double y, double z, double t) {
double t_1 = (x / y) + ((2.0 + ((2.0 * z) * (1.0 - t))) / (z * t));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = (x / y) - 2.0;
}
return tmp;
}
public static double code(double x, double y, double z, double t) {
double t_1 = (x / y) + ((2.0 + ((2.0 * z) * (1.0 - t))) / (z * t));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = (x / y) - 2.0;
}
return tmp;
}
def code(x, y, z, t): t_1 = (x / y) + ((2.0 + ((2.0 * z) * (1.0 - t))) / (z * t)) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = (x / y) - 2.0 return tmp
function code(x, y, z, t) t_1 = Float64(Float64(x / y) + Float64(Float64(2.0 + Float64(Float64(2.0 * z) * Float64(1.0 - t))) / Float64(z * t))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(Float64(x / y) - 2.0); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (x / y) + ((2.0 + ((2.0 * z) * (1.0 - t))) / (z * t)); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = (x / y) - 2.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 + N[(N[(2.0 * z), $MachinePrecision] * N[(1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[(x / y), $MachinePrecision] - 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y} + \frac{2 + \left(2 \cdot z\right) \cdot \left(1 - t\right)}{z \cdot t}\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} - 2\\
\end{array}
\end{array}
if (+.f64 (/.f64 x y) (/.f64 (+.f64 #s(literal 2 binary64) (*.f64 (*.f64 z #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) t))) (*.f64 t z))) < +inf.0Initial program 99.3%
if +inf.0 < (+.f64 (/.f64 x y) (/.f64 (+.f64 #s(literal 2 binary64) (*.f64 (*.f64 z #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) t))) (*.f64 t z))) Initial program 0.0%
Taylor expanded in t around inf 100.0%
Final simplification99.4%
(FPCore (x y z t)
:precision binary64
(if (<= (/ x y) -8e+49)
(/ x y)
(if (<= (/ x y) -2.15e-47)
(/ 2.0 t)
(if (<= (/ x y) 2.5e-214)
-2.0
(if (<= (/ x y) 6.6e+25) (/ 2.0 t) (/ x y))))))
double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -8e+49) {
tmp = x / y;
} else if ((x / y) <= -2.15e-47) {
tmp = 2.0 / t;
} else if ((x / y) <= 2.5e-214) {
tmp = -2.0;
} else if ((x / y) <= 6.6e+25) {
tmp = 2.0 / t;
} else {
tmp = x / 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 ((x / y) <= (-8d+49)) then
tmp = x / y
else if ((x / y) <= (-2.15d-47)) then
tmp = 2.0d0 / t
else if ((x / y) <= 2.5d-214) then
tmp = -2.0d0
else if ((x / y) <= 6.6d+25) then
tmp = 2.0d0 / t
else
tmp = x / y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -8e+49) {
tmp = x / y;
} else if ((x / y) <= -2.15e-47) {
tmp = 2.0 / t;
} else if ((x / y) <= 2.5e-214) {
tmp = -2.0;
} else if ((x / y) <= 6.6e+25) {
tmp = 2.0 / t;
} else {
tmp = x / y;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (x / y) <= -8e+49: tmp = x / y elif (x / y) <= -2.15e-47: tmp = 2.0 / t elif (x / y) <= 2.5e-214: tmp = -2.0 elif (x / y) <= 6.6e+25: tmp = 2.0 / t else: tmp = x / y return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(x / y) <= -8e+49) tmp = Float64(x / y); elseif (Float64(x / y) <= -2.15e-47) tmp = Float64(2.0 / t); elseif (Float64(x / y) <= 2.5e-214) tmp = -2.0; elseif (Float64(x / y) <= 6.6e+25) tmp = Float64(2.0 / t); else tmp = Float64(x / y); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((x / y) <= -8e+49) tmp = x / y; elseif ((x / y) <= -2.15e-47) tmp = 2.0 / t; elseif ((x / y) <= 2.5e-214) tmp = -2.0; elseif ((x / y) <= 6.6e+25) tmp = 2.0 / t; else tmp = x / y; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(x / y), $MachinePrecision], -8e+49], N[(x / y), $MachinePrecision], If[LessEqual[N[(x / y), $MachinePrecision], -2.15e-47], N[(2.0 / t), $MachinePrecision], If[LessEqual[N[(x / y), $MachinePrecision], 2.5e-214], -2.0, If[LessEqual[N[(x / y), $MachinePrecision], 6.6e+25], N[(2.0 / t), $MachinePrecision], N[(x / y), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} \leq -8 \cdot 10^{+49}:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{elif}\;\frac{x}{y} \leq -2.15 \cdot 10^{-47}:\\
\;\;\;\;\frac{2}{t}\\
\mathbf{elif}\;\frac{x}{y} \leq 2.5 \cdot 10^{-214}:\\
\;\;\;\;-2\\
\mathbf{elif}\;\frac{x}{y} \leq 6.6 \cdot 10^{+25}:\\
\;\;\;\;\frac{2}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y}\\
\end{array}
\end{array}
if (/.f64 x y) < -7.99999999999999957e49 or 6.6000000000000002e25 < (/.f64 x y) Initial program 88.7%
Taylor expanded in x around inf 64.9%
if -7.99999999999999957e49 < (/.f64 x y) < -2.1499999999999999e-47 or 2.4999999999999999e-214 < (/.f64 x y) < 6.6000000000000002e25Initial program 91.8%
Taylor expanded in t around 0 78.6%
associate-*r/78.6%
metadata-eval78.6%
Simplified78.6%
Taylor expanded in z around inf 38.3%
if -2.1499999999999999e-47 < (/.f64 x y) < 2.4999999999999999e-214Initial program 85.8%
Taylor expanded in t around inf 43.7%
Taylor expanded in x around 0 43.7%
(FPCore (x y z t)
:precision binary64
(if (<= (/ x y) -5e+119)
(+ (/ x y) (+ (/ 2.0 t) -2.0))
(if (or (<= (/ x y) -1e+56) (not (<= (/ x y) 5e+16)))
(+ (/ x y) (/ (/ 2.0 t) z))
(+ -2.0 (/ (+ 2.0 (/ 2.0 z)) t)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -5e+119) {
tmp = (x / y) + ((2.0 / t) + -2.0);
} else if (((x / y) <= -1e+56) || !((x / y) <= 5e+16)) {
tmp = (x / y) + ((2.0 / t) / z);
} else {
tmp = -2.0 + ((2.0 + (2.0 / 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) :: tmp
if ((x / y) <= (-5d+119)) then
tmp = (x / y) + ((2.0d0 / t) + (-2.0d0))
else if (((x / y) <= (-1d+56)) .or. (.not. ((x / y) <= 5d+16))) then
tmp = (x / y) + ((2.0d0 / t) / z)
else
tmp = (-2.0d0) + ((2.0d0 + (2.0d0 / z)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -5e+119) {
tmp = (x / y) + ((2.0 / t) + -2.0);
} else if (((x / y) <= -1e+56) || !((x / y) <= 5e+16)) {
tmp = (x / y) + ((2.0 / t) / z);
} else {
tmp = -2.0 + ((2.0 + (2.0 / z)) / t);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (x / y) <= -5e+119: tmp = (x / y) + ((2.0 / t) + -2.0) elif ((x / y) <= -1e+56) or not ((x / y) <= 5e+16): tmp = (x / y) + ((2.0 / t) / z) else: tmp = -2.0 + ((2.0 + (2.0 / z)) / t) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(x / y) <= -5e+119) tmp = Float64(Float64(x / y) + Float64(Float64(2.0 / t) + -2.0)); elseif ((Float64(x / y) <= -1e+56) || !(Float64(x / y) <= 5e+16)) tmp = Float64(Float64(x / y) + Float64(Float64(2.0 / t) / z)); else tmp = Float64(-2.0 + Float64(Float64(2.0 + Float64(2.0 / z)) / t)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((x / y) <= -5e+119) tmp = (x / y) + ((2.0 / t) + -2.0); elseif (((x / y) <= -1e+56) || ~(((x / y) <= 5e+16))) tmp = (x / y) + ((2.0 / t) / z); else tmp = -2.0 + ((2.0 + (2.0 / z)) / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(x / y), $MachinePrecision], -5e+119], N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[N[(x / y), $MachinePrecision], -1e+56], N[Not[LessEqual[N[(x / y), $MachinePrecision], 5e+16]], $MachinePrecision]], N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 / t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(-2.0 + N[(N[(2.0 + N[(2.0 / z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} \leq -5 \cdot 10^{+119}:\\
\;\;\;\;\frac{x}{y} + \left(\frac{2}{t} + -2\right)\\
\mathbf{elif}\;\frac{x}{y} \leq -1 \cdot 10^{+56} \lor \neg \left(\frac{x}{y} \leq 5 \cdot 10^{+16}\right):\\
\;\;\;\;\frac{x}{y} + \frac{\frac{2}{t}}{z}\\
\mathbf{else}:\\
\;\;\;\;-2 + \frac{2 + \frac{2}{z}}{t}\\
\end{array}
\end{array}
if (/.f64 x y) < -4.9999999999999999e119Initial program 87.8%
Taylor expanded in z around inf 93.9%
div-sub93.9%
sub-neg93.9%
*-inverses93.9%
metadata-eval93.9%
distribute-lft-in93.9%
metadata-eval93.9%
associate-*r/93.9%
metadata-eval93.9%
Simplified93.9%
if -4.9999999999999999e119 < (/.f64 x y) < -1.00000000000000009e56 or 5e16 < (/.f64 x y) Initial program 88.9%
Taylor expanded in z around 0 92.0%
associate-/r*92.0%
Simplified92.0%
if -1.00000000000000009e56 < (/.f64 x y) < 5e16Initial program 88.4%
Taylor expanded in x around inf 66.8%
*-commutative66.8%
associate-/r*70.4%
associate-*l/70.4%
*-commutative70.4%
div-sub70.4%
sub-neg70.4%
*-inverses70.4%
metadata-eval70.4%
distribute-lft-in70.4%
metadata-eval70.4%
associate-*r/70.4%
metadata-eval70.4%
*-commutative70.4%
Simplified70.4%
Taylor expanded in x around 0 97.7%
sub-neg97.7%
metadata-eval97.7%
+-commutative97.7%
*-commutative97.7%
associate-/r*97.7%
associate-*r/97.7%
*-commutative97.7%
associate-/l*97.7%
metadata-eval97.7%
associate-*r/97.7%
distribute-lft-in97.6%
associate-*r/97.6%
metadata-eval97.6%
associate-*l/97.7%
*-lft-identity97.7%
Simplified97.7%
Final simplification95.6%
(FPCore (x y z t)
:precision binary64
(if (<= (/ x y) -5e+119)
(+ (/ x y) (+ (/ 2.0 t) -2.0))
(if (or (<= (/ x y) -1e+56) (not (<= (/ x y) 5e+16)))
(+ (/ x y) (/ 2.0 (* z t)))
(+ -2.0 (/ (+ 2.0 (/ 2.0 z)) t)))))
double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -5e+119) {
tmp = (x / y) + ((2.0 / t) + -2.0);
} else if (((x / y) <= -1e+56) || !((x / y) <= 5e+16)) {
tmp = (x / y) + (2.0 / (z * t));
} else {
tmp = -2.0 + ((2.0 + (2.0 / 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) :: tmp
if ((x / y) <= (-5d+119)) then
tmp = (x / y) + ((2.0d0 / t) + (-2.0d0))
else if (((x / y) <= (-1d+56)) .or. (.not. ((x / y) <= 5d+16))) then
tmp = (x / y) + (2.0d0 / (z * t))
else
tmp = (-2.0d0) + ((2.0d0 + (2.0d0 / z)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -5e+119) {
tmp = (x / y) + ((2.0 / t) + -2.0);
} else if (((x / y) <= -1e+56) || !((x / y) <= 5e+16)) {
tmp = (x / y) + (2.0 / (z * t));
} else {
tmp = -2.0 + ((2.0 + (2.0 / z)) / t);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (x / y) <= -5e+119: tmp = (x / y) + ((2.0 / t) + -2.0) elif ((x / y) <= -1e+56) or not ((x / y) <= 5e+16): tmp = (x / y) + (2.0 / (z * t)) else: tmp = -2.0 + ((2.0 + (2.0 / z)) / t) return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(x / y) <= -5e+119) tmp = Float64(Float64(x / y) + Float64(Float64(2.0 / t) + -2.0)); elseif ((Float64(x / y) <= -1e+56) || !(Float64(x / y) <= 5e+16)) tmp = Float64(Float64(x / y) + Float64(2.0 / Float64(z * t))); else tmp = Float64(-2.0 + Float64(Float64(2.0 + Float64(2.0 / z)) / t)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((x / y) <= -5e+119) tmp = (x / y) + ((2.0 / t) + -2.0); elseif (((x / y) <= -1e+56) || ~(((x / y) <= 5e+16))) tmp = (x / y) + (2.0 / (z * t)); else tmp = -2.0 + ((2.0 + (2.0 / z)) / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(x / y), $MachinePrecision], -5e+119], N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[N[(x / y), $MachinePrecision], -1e+56], N[Not[LessEqual[N[(x / y), $MachinePrecision], 5e+16]], $MachinePrecision]], N[(N[(x / y), $MachinePrecision] + N[(2.0 / N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-2.0 + N[(N[(2.0 + N[(2.0 / z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} \leq -5 \cdot 10^{+119}:\\
\;\;\;\;\frac{x}{y} + \left(\frac{2}{t} + -2\right)\\
\mathbf{elif}\;\frac{x}{y} \leq -1 \cdot 10^{+56} \lor \neg \left(\frac{x}{y} \leq 5 \cdot 10^{+16}\right):\\
\;\;\;\;\frac{x}{y} + \frac{2}{z \cdot t}\\
\mathbf{else}:\\
\;\;\;\;-2 + \frac{2 + \frac{2}{z}}{t}\\
\end{array}
\end{array}
if (/.f64 x y) < -4.9999999999999999e119Initial program 87.8%
Taylor expanded in z around inf 93.9%
div-sub93.9%
sub-neg93.9%
*-inverses93.9%
metadata-eval93.9%
distribute-lft-in93.9%
metadata-eval93.9%
associate-*r/93.9%
metadata-eval93.9%
Simplified93.9%
if -4.9999999999999999e119 < (/.f64 x y) < -1.00000000000000009e56 or 5e16 < (/.f64 x y) Initial program 88.9%
Taylor expanded in z around 0 92.0%
if -1.00000000000000009e56 < (/.f64 x y) < 5e16Initial program 88.4%
Taylor expanded in x around inf 66.8%
*-commutative66.8%
associate-/r*70.4%
associate-*l/70.4%
*-commutative70.4%
div-sub70.4%
sub-neg70.4%
*-inverses70.4%
metadata-eval70.4%
distribute-lft-in70.4%
metadata-eval70.4%
associate-*r/70.4%
metadata-eval70.4%
*-commutative70.4%
Simplified70.4%
Taylor expanded in x around 0 97.7%
sub-neg97.7%
metadata-eval97.7%
+-commutative97.7%
*-commutative97.7%
associate-/r*97.7%
associate-*r/97.7%
*-commutative97.7%
associate-/l*97.7%
metadata-eval97.7%
associate-*r/97.7%
distribute-lft-in97.6%
associate-*r/97.6%
metadata-eval97.6%
associate-*l/97.7%
*-lft-identity97.7%
Simplified97.7%
Final simplification95.6%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (/ x y) 2.0)))
(if (<= t -2e+200)
t_1
(if (<= t -1.28e+23)
(+ -2.0 (/ 2.0 (* z t)))
(if (or (<= t -1.6e-72) (not (<= t 5.8e-48)))
t_1
(/ (+ 2.0 (/ 2.0 z)) t))))))
double code(double x, double y, double z, double t) {
double t_1 = (x / y) - 2.0;
double tmp;
if (t <= -2e+200) {
tmp = t_1;
} else if (t <= -1.28e+23) {
tmp = -2.0 + (2.0 / (z * t));
} else if ((t <= -1.6e-72) || !(t <= 5.8e-48)) {
tmp = t_1;
} else {
tmp = (2.0 + (2.0 / 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 = (x / y) - 2.0d0
if (t <= (-2d+200)) then
tmp = t_1
else if (t <= (-1.28d+23)) then
tmp = (-2.0d0) + (2.0d0 / (z * t))
else if ((t <= (-1.6d-72)) .or. (.not. (t <= 5.8d-48))) then
tmp = t_1
else
tmp = (2.0d0 + (2.0d0 / z)) / t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double t_1 = (x / y) - 2.0;
double tmp;
if (t <= -2e+200) {
tmp = t_1;
} else if (t <= -1.28e+23) {
tmp = -2.0 + (2.0 / (z * t));
} else if ((t <= -1.6e-72) || !(t <= 5.8e-48)) {
tmp = t_1;
} else {
tmp = (2.0 + (2.0 / z)) / t;
}
return tmp;
}
def code(x, y, z, t): t_1 = (x / y) - 2.0 tmp = 0 if t <= -2e+200: tmp = t_1 elif t <= -1.28e+23: tmp = -2.0 + (2.0 / (z * t)) elif (t <= -1.6e-72) or not (t <= 5.8e-48): tmp = t_1 else: tmp = (2.0 + (2.0 / z)) / t return tmp
function code(x, y, z, t) t_1 = Float64(Float64(x / y) - 2.0) tmp = 0.0 if (t <= -2e+200) tmp = t_1; elseif (t <= -1.28e+23) tmp = Float64(-2.0 + Float64(2.0 / Float64(z * t))); elseif ((t <= -1.6e-72) || !(t <= 5.8e-48)) tmp = t_1; else tmp = Float64(Float64(2.0 + Float64(2.0 / z)) / t); end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (x / y) - 2.0; tmp = 0.0; if (t <= -2e+200) tmp = t_1; elseif (t <= -1.28e+23) tmp = -2.0 + (2.0 / (z * t)); elseif ((t <= -1.6e-72) || ~((t <= 5.8e-48))) tmp = t_1; else tmp = (2.0 + (2.0 / z)) / t; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(x / y), $MachinePrecision] - 2.0), $MachinePrecision]}, If[LessEqual[t, -2e+200], t$95$1, If[LessEqual[t, -1.28e+23], N[(-2.0 + N[(2.0 / N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, -1.6e-72], N[Not[LessEqual[t, 5.8e-48]], $MachinePrecision]], t$95$1, N[(N[(2.0 + N[(2.0 / z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y} - 2\\
\mathbf{if}\;t \leq -2 \cdot 10^{+200}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -1.28 \cdot 10^{+23}:\\
\;\;\;\;-2 + \frac{2}{z \cdot t}\\
\mathbf{elif}\;t \leq -1.6 \cdot 10^{-72} \lor \neg \left(t \leq 5.8 \cdot 10^{-48}\right):\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{2 + \frac{2}{z}}{t}\\
\end{array}
\end{array}
if t < -1.9999999999999999e200 or -1.28e23 < t < -1.6e-72 or 5.8000000000000006e-48 < t Initial program 79.1%
Taylor expanded in t around inf 78.7%
if -1.9999999999999999e200 < t < -1.28e23Initial program 82.6%
Taylor expanded in x around inf 74.8%
*-commutative74.8%
associate-/r*74.9%
associate-*l/74.9%
*-commutative74.9%
div-sub74.9%
sub-neg74.9%
*-inverses74.9%
metadata-eval74.9%
distribute-lft-in74.9%
metadata-eval74.9%
associate-*r/74.9%
metadata-eval74.9%
*-commutative74.9%
Simplified74.9%
Taylor expanded in x around 0 75.0%
sub-neg75.0%
associate-*r/75.0%
metadata-eval75.0%
associate-*r/75.0%
metadata-eval75.0%
+-commutative75.0%
metadata-eval75.0%
Simplified75.0%
Taylor expanded in z around 0 75.0%
*-commutative75.0%
Simplified75.0%
if -1.6e-72 < t < 5.8000000000000006e-48Initial program 98.9%
Taylor expanded in t around 0 87.5%
associate-*r/87.5%
metadata-eval87.5%
Simplified87.5%
Final simplification82.1%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ (/ 2.0 t) -2.0)) (t_2 (- (/ x y) 2.0)))
(if (<= z -1.46e+96)
t_2
(if (<= z -1.0)
t_1
(if (<= z 1.46e-38)
(+ -2.0 (/ 2.0 (* z t)))
(if (<= z 9e+193) t_2 t_1))))))
double code(double x, double y, double z, double t) {
double t_1 = (2.0 / t) + -2.0;
double t_2 = (x / y) - 2.0;
double tmp;
if (z <= -1.46e+96) {
tmp = t_2;
} else if (z <= -1.0) {
tmp = t_1;
} else if (z <= 1.46e-38) {
tmp = -2.0 + (2.0 / (z * t));
} else if (z <= 9e+193) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = (2.0d0 / t) + (-2.0d0)
t_2 = (x / y) - 2.0d0
if (z <= (-1.46d+96)) then
tmp = t_2
else if (z <= (-1.0d0)) then
tmp = t_1
else if (z <= 1.46d-38) then
tmp = (-2.0d0) + (2.0d0 / (z * t))
else if (z <= 9d+193) then
tmp = t_2
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 = (2.0 / t) + -2.0;
double t_2 = (x / y) - 2.0;
double tmp;
if (z <= -1.46e+96) {
tmp = t_2;
} else if (z <= -1.0) {
tmp = t_1;
} else if (z <= 1.46e-38) {
tmp = -2.0 + (2.0 / (z * t));
} else if (z <= 9e+193) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = (2.0 / t) + -2.0 t_2 = (x / y) - 2.0 tmp = 0 if z <= -1.46e+96: tmp = t_2 elif z <= -1.0: tmp = t_1 elif z <= 1.46e-38: tmp = -2.0 + (2.0 / (z * t)) elif z <= 9e+193: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(Float64(2.0 / t) + -2.0) t_2 = Float64(Float64(x / y) - 2.0) tmp = 0.0 if (z <= -1.46e+96) tmp = t_2; elseif (z <= -1.0) tmp = t_1; elseif (z <= 1.46e-38) tmp = Float64(-2.0 + Float64(2.0 / Float64(z * t))); elseif (z <= 9e+193) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (2.0 / t) + -2.0; t_2 = (x / y) - 2.0; tmp = 0.0; if (z <= -1.46e+96) tmp = t_2; elseif (z <= -1.0) tmp = t_1; elseif (z <= 1.46e-38) tmp = -2.0 + (2.0 / (z * t)); elseif (z <= 9e+193) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / y), $MachinePrecision] - 2.0), $MachinePrecision]}, If[LessEqual[z, -1.46e+96], t$95$2, If[LessEqual[z, -1.0], t$95$1, If[LessEqual[z, 1.46e-38], N[(-2.0 + N[(2.0 / N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9e+193], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{2}{t} + -2\\
t_2 := \frac{x}{y} - 2\\
\mathbf{if}\;z \leq -1.46 \cdot 10^{+96}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -1:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.46 \cdot 10^{-38}:\\
\;\;\;\;-2 + \frac{2}{z \cdot t}\\
\mathbf{elif}\;z \leq 9 \cdot 10^{+193}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.4600000000000001e96 or 1.4599999999999999e-38 < z < 8.99999999999999999e193Initial program 81.6%
Taylor expanded in t around inf 68.8%
if -1.4600000000000001e96 < z < -1 or 8.99999999999999999e193 < z Initial program 75.4%
Taylor expanded in x around inf 83.1%
*-commutative83.1%
associate-/r*83.1%
associate-*l/83.1%
*-commutative83.1%
div-sub83.2%
sub-neg83.2%
*-inverses83.2%
metadata-eval83.2%
distribute-lft-in83.2%
metadata-eval83.2%
associate-*r/83.2%
metadata-eval83.2%
*-commutative83.2%
Simplified83.2%
Taylor expanded in x around 0 72.0%
sub-neg72.0%
metadata-eval72.0%
+-commutative72.0%
*-commutative72.0%
associate-/r*72.0%
associate-*r/72.0%
*-commutative72.0%
associate-/l*72.0%
metadata-eval72.0%
associate-*r/72.0%
distribute-lft-in72.0%
associate-*r/72.0%
metadata-eval72.0%
associate-*l/72.1%
*-lft-identity72.1%
Simplified72.1%
Taylor expanded in z around inf 70.0%
if -1 < z < 1.4599999999999999e-38Initial program 98.9%
Taylor expanded in x around inf 68.7%
*-commutative68.7%
associate-/r*70.4%
associate-*l/70.4%
*-commutative70.4%
div-sub70.4%
sub-neg70.4%
*-inverses70.4%
metadata-eval70.4%
distribute-lft-in70.4%
metadata-eval70.4%
associate-*r/70.4%
metadata-eval70.4%
*-commutative70.4%
Simplified70.4%
Taylor expanded in x around 0 82.2%
sub-neg82.2%
associate-*r/82.2%
metadata-eval82.2%
associate-*r/82.2%
metadata-eval82.2%
+-commutative82.2%
metadata-eval82.2%
Simplified82.2%
Taylor expanded in z around 0 82.2%
*-commutative82.2%
Simplified82.2%
Final simplification75.2%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ (/ 2.0 t) -2.0)) (t_2 (- (/ x y) 2.0)))
(if (<= z -1.25e+92)
t_2
(if (<= z -9e-13)
t_1
(if (<= z 7.3e-41) (/ (/ 2.0 t) z) (if (<= z 6.1e+193) t_2 t_1))))))
double code(double x, double y, double z, double t) {
double t_1 = (2.0 / t) + -2.0;
double t_2 = (x / y) - 2.0;
double tmp;
if (z <= -1.25e+92) {
tmp = t_2;
} else if (z <= -9e-13) {
tmp = t_1;
} else if (z <= 7.3e-41) {
tmp = (2.0 / t) / z;
} else if (z <= 6.1e+193) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = (2.0d0 / t) + (-2.0d0)
t_2 = (x / y) - 2.0d0
if (z <= (-1.25d+92)) then
tmp = t_2
else if (z <= (-9d-13)) then
tmp = t_1
else if (z <= 7.3d-41) then
tmp = (2.0d0 / t) / z
else if (z <= 6.1d+193) then
tmp = t_2
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 = (2.0 / t) + -2.0;
double t_2 = (x / y) - 2.0;
double tmp;
if (z <= -1.25e+92) {
tmp = t_2;
} else if (z <= -9e-13) {
tmp = t_1;
} else if (z <= 7.3e-41) {
tmp = (2.0 / t) / z;
} else if (z <= 6.1e+193) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = (2.0 / t) + -2.0 t_2 = (x / y) - 2.0 tmp = 0 if z <= -1.25e+92: tmp = t_2 elif z <= -9e-13: tmp = t_1 elif z <= 7.3e-41: tmp = (2.0 / t) / z elif z <= 6.1e+193: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(Float64(2.0 / t) + -2.0) t_2 = Float64(Float64(x / y) - 2.0) tmp = 0.0 if (z <= -1.25e+92) tmp = t_2; elseif (z <= -9e-13) tmp = t_1; elseif (z <= 7.3e-41) tmp = Float64(Float64(2.0 / t) / z); elseif (z <= 6.1e+193) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (2.0 / t) + -2.0; t_2 = (x / y) - 2.0; tmp = 0.0; if (z <= -1.25e+92) tmp = t_2; elseif (z <= -9e-13) tmp = t_1; elseif (z <= 7.3e-41) tmp = (2.0 / t) / z; elseif (z <= 6.1e+193) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / y), $MachinePrecision] - 2.0), $MachinePrecision]}, If[LessEqual[z, -1.25e+92], t$95$2, If[LessEqual[z, -9e-13], t$95$1, If[LessEqual[z, 7.3e-41], N[(N[(2.0 / t), $MachinePrecision] / z), $MachinePrecision], If[LessEqual[z, 6.1e+193], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{2}{t} + -2\\
t_2 := \frac{x}{y} - 2\\
\mathbf{if}\;z \leq -1.25 \cdot 10^{+92}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -9 \cdot 10^{-13}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 7.3 \cdot 10^{-41}:\\
\;\;\;\;\frac{\frac{2}{t}}{z}\\
\mathbf{elif}\;z \leq 6.1 \cdot 10^{+193}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.25000000000000005e92 or 7.30000000000000026e-41 < z < 6.1000000000000003e193Initial program 81.6%
Taylor expanded in t around inf 68.8%
if -1.25000000000000005e92 < z < -9e-13 or 6.1000000000000003e193 < z Initial program 75.4%
Taylor expanded in x around inf 83.1%
*-commutative83.1%
associate-/r*83.1%
associate-*l/83.1%
*-commutative83.1%
div-sub83.2%
sub-neg83.2%
*-inverses83.2%
metadata-eval83.2%
distribute-lft-in83.2%
metadata-eval83.2%
associate-*r/83.2%
metadata-eval83.2%
*-commutative83.2%
Simplified83.2%
Taylor expanded in x around 0 72.0%
sub-neg72.0%
metadata-eval72.0%
+-commutative72.0%
*-commutative72.0%
associate-/r*72.0%
associate-*r/72.0%
*-commutative72.0%
associate-/l*72.0%
metadata-eval72.0%
associate-*r/72.0%
distribute-lft-in72.0%
associate-*r/72.0%
metadata-eval72.0%
associate-*l/72.1%
*-lft-identity72.1%
Simplified72.1%
Taylor expanded in z around inf 70.0%
if -9e-13 < z < 7.30000000000000026e-41Initial program 98.9%
Taylor expanded in x around inf 68.7%
*-commutative68.7%
associate-/r*70.4%
associate-*l/70.4%
*-commutative70.4%
div-sub70.4%
sub-neg70.4%
*-inverses70.4%
metadata-eval70.4%
distribute-lft-in70.4%
metadata-eval70.4%
associate-*r/70.4%
metadata-eval70.4%
*-commutative70.4%
Simplified70.4%
Taylor expanded in z around 0 53.3%
associate-*r*56.6%
associate-/r*56.7%
Simplified56.7%
Taylor expanded in x around 0 71.9%
associate-/r*72.0%
Simplified72.0%
Final simplification70.5%
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (+ (/ 2.0 t) -2.0)) (t_2 (- (/ x y) 2.0)))
(if (<= z -3.3e+96)
t_2
(if (<= z -1.3e-11)
t_1
(if (<= z 1.76e-40) (/ 2.0 (* z t)) (if (<= z 5.6e+193) t_2 t_1))))))
double code(double x, double y, double z, double t) {
double t_1 = (2.0 / t) + -2.0;
double t_2 = (x / y) - 2.0;
double tmp;
if (z <= -3.3e+96) {
tmp = t_2;
} else if (z <= -1.3e-11) {
tmp = t_1;
} else if (z <= 1.76e-40) {
tmp = 2.0 / (z * t);
} else if (z <= 5.6e+193) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = (2.0d0 / t) + (-2.0d0)
t_2 = (x / y) - 2.0d0
if (z <= (-3.3d+96)) then
tmp = t_2
else if (z <= (-1.3d-11)) then
tmp = t_1
else if (z <= 1.76d-40) then
tmp = 2.0d0 / (z * t)
else if (z <= 5.6d+193) then
tmp = t_2
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 = (2.0 / t) + -2.0;
double t_2 = (x / y) - 2.0;
double tmp;
if (z <= -3.3e+96) {
tmp = t_2;
} else if (z <= -1.3e-11) {
tmp = t_1;
} else if (z <= 1.76e-40) {
tmp = 2.0 / (z * t);
} else if (z <= 5.6e+193) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t): t_1 = (2.0 / t) + -2.0 t_2 = (x / y) - 2.0 tmp = 0 if z <= -3.3e+96: tmp = t_2 elif z <= -1.3e-11: tmp = t_1 elif z <= 1.76e-40: tmp = 2.0 / (z * t) elif z <= 5.6e+193: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t) t_1 = Float64(Float64(2.0 / t) + -2.0) t_2 = Float64(Float64(x / y) - 2.0) tmp = 0.0 if (z <= -3.3e+96) tmp = t_2; elseif (z <= -1.3e-11) tmp = t_1; elseif (z <= 1.76e-40) tmp = Float64(2.0 / Float64(z * t)); elseif (z <= 5.6e+193) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t) t_1 = (2.0 / t) + -2.0; t_2 = (x / y) - 2.0; tmp = 0.0; if (z <= -3.3e+96) tmp = t_2; elseif (z <= -1.3e-11) tmp = t_1; elseif (z <= 1.76e-40) tmp = 2.0 / (z * t); elseif (z <= 5.6e+193) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / y), $MachinePrecision] - 2.0), $MachinePrecision]}, If[LessEqual[z, -3.3e+96], t$95$2, If[LessEqual[z, -1.3e-11], t$95$1, If[LessEqual[z, 1.76e-40], N[(2.0 / N[(z * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.6e+193], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{2}{t} + -2\\
t_2 := \frac{x}{y} - 2\\
\mathbf{if}\;z \leq -3.3 \cdot 10^{+96}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{-11}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.76 \cdot 10^{-40}:\\
\;\;\;\;\frac{2}{z \cdot t}\\
\mathbf{elif}\;z \leq 5.6 \cdot 10^{+193}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.29999999999999984e96 or 1.76e-40 < z < 5.59999999999999972e193Initial program 81.6%
Taylor expanded in t around inf 68.8%
if -3.29999999999999984e96 < z < -1.3e-11 or 5.59999999999999972e193 < z Initial program 75.4%
Taylor expanded in x around inf 83.1%
*-commutative83.1%
associate-/r*83.1%
associate-*l/83.1%
*-commutative83.1%
div-sub83.2%
sub-neg83.2%
*-inverses83.2%
metadata-eval83.2%
distribute-lft-in83.2%
metadata-eval83.2%
associate-*r/83.2%
metadata-eval83.2%
*-commutative83.2%
Simplified83.2%
Taylor expanded in x around 0 72.0%
sub-neg72.0%
metadata-eval72.0%
+-commutative72.0%
*-commutative72.0%
associate-/r*72.0%
associate-*r/72.0%
*-commutative72.0%
associate-/l*72.0%
metadata-eval72.0%
associate-*r/72.0%
distribute-lft-in72.0%
associate-*r/72.0%
metadata-eval72.0%
associate-*l/72.1%
*-lft-identity72.1%
Simplified72.1%
Taylor expanded in z around inf 70.0%
if -1.3e-11 < z < 1.76e-40Initial program 98.9%
Taylor expanded in x around inf 68.7%
*-commutative68.7%
associate-/r*70.4%
associate-*l/70.4%
*-commutative70.4%
div-sub70.4%
sub-neg70.4%
*-inverses70.4%
metadata-eval70.4%
distribute-lft-in70.4%
metadata-eval70.4%
associate-*r/70.4%
metadata-eval70.4%
*-commutative70.4%
Simplified70.4%
Taylor expanded in z around 0 71.9%
Final simplification70.4%
(FPCore (x y z t) :precision binary64 (if (or (<= (/ x y) -5e+119) (not (<= (/ x y) 1e+130))) (+ (/ x y) (+ (/ 2.0 t) -2.0)) (+ -2.0 (/ (+ 2.0 (/ 2.0 z)) t))))
double code(double x, double y, double z, double t) {
double tmp;
if (((x / y) <= -5e+119) || !((x / y) <= 1e+130)) {
tmp = (x / y) + ((2.0 / t) + -2.0);
} else {
tmp = -2.0 + ((2.0 + (2.0 / 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) :: tmp
if (((x / y) <= (-5d+119)) .or. (.not. ((x / y) <= 1d+130))) then
tmp = (x / y) + ((2.0d0 / t) + (-2.0d0))
else
tmp = (-2.0d0) + ((2.0d0 + (2.0d0 / z)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((x / y) <= -5e+119) || !((x / y) <= 1e+130)) {
tmp = (x / y) + ((2.0 / t) + -2.0);
} else {
tmp = -2.0 + ((2.0 + (2.0 / z)) / t);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((x / y) <= -5e+119) or not ((x / y) <= 1e+130): tmp = (x / y) + ((2.0 / t) + -2.0) else: tmp = -2.0 + ((2.0 + (2.0 / z)) / t) return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(x / y) <= -5e+119) || !(Float64(x / y) <= 1e+130)) tmp = Float64(Float64(x / y) + Float64(Float64(2.0 / t) + -2.0)); else tmp = Float64(-2.0 + Float64(Float64(2.0 + Float64(2.0 / z)) / t)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((x / y) <= -5e+119) || ~(((x / y) <= 1e+130))) tmp = (x / y) + ((2.0 / t) + -2.0); else tmp = -2.0 + ((2.0 + (2.0 / z)) / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(x / y), $MachinePrecision], -5e+119], N[Not[LessEqual[N[(x / y), $MachinePrecision], 1e+130]], $MachinePrecision]], N[(N[(x / y), $MachinePrecision] + N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision]), $MachinePrecision], N[(-2.0 + N[(N[(2.0 + N[(2.0 / z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} \leq -5 \cdot 10^{+119} \lor \neg \left(\frac{x}{y} \leq 10^{+130}\right):\\
\;\;\;\;\frac{x}{y} + \left(\frac{2}{t} + -2\right)\\
\mathbf{else}:\\
\;\;\;\;-2 + \frac{2 + \frac{2}{z}}{t}\\
\end{array}
\end{array}
if (/.f64 x y) < -4.9999999999999999e119 or 1.0000000000000001e130 < (/.f64 x y) Initial program 90.1%
Taylor expanded in z around inf 90.3%
div-sub90.3%
sub-neg90.3%
*-inverses90.3%
metadata-eval90.3%
distribute-lft-in90.3%
metadata-eval90.3%
associate-*r/90.3%
metadata-eval90.3%
Simplified90.3%
if -4.9999999999999999e119 < (/.f64 x y) < 1.0000000000000001e130Initial program 87.8%
Taylor expanded in x around inf 71.5%
*-commutative71.5%
associate-/r*74.5%
associate-*l/74.5%
*-commutative74.5%
div-sub74.5%
sub-neg74.5%
*-inverses74.5%
metadata-eval74.5%
distribute-lft-in74.5%
metadata-eval74.5%
associate-*r/74.5%
metadata-eval74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in x around 0 91.6%
sub-neg91.6%
metadata-eval91.6%
+-commutative91.6%
*-commutative91.6%
associate-/r*91.7%
associate-*r/91.7%
*-commutative91.7%
associate-/l*91.6%
metadata-eval91.6%
associate-*r/91.6%
distribute-lft-in91.6%
associate-*r/91.6%
metadata-eval91.6%
associate-*l/91.7%
*-lft-identity91.7%
Simplified91.7%
Final simplification91.3%
(FPCore (x y z t) :precision binary64 (if (or (<= (/ x y) -5e+198) (not (<= (/ x y) 1e+130))) (/ x y) (+ -2.0 (/ (+ 2.0 (/ 2.0 z)) t))))
double code(double x, double y, double z, double t) {
double tmp;
if (((x / y) <= -5e+198) || !((x / y) <= 1e+130)) {
tmp = x / y;
} else {
tmp = -2.0 + ((2.0 + (2.0 / 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) :: tmp
if (((x / y) <= (-5d+198)) .or. (.not. ((x / y) <= 1d+130))) then
tmp = x / y
else
tmp = (-2.0d0) + ((2.0d0 + (2.0d0 / z)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((x / y) <= -5e+198) || !((x / y) <= 1e+130)) {
tmp = x / y;
} else {
tmp = -2.0 + ((2.0 + (2.0 / z)) / t);
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((x / y) <= -5e+198) or not ((x / y) <= 1e+130): tmp = x / y else: tmp = -2.0 + ((2.0 + (2.0 / z)) / t) return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(x / y) <= -5e+198) || !(Float64(x / y) <= 1e+130)) tmp = Float64(x / y); else tmp = Float64(-2.0 + Float64(Float64(2.0 + Float64(2.0 / z)) / t)); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((x / y) <= -5e+198) || ~(((x / y) <= 1e+130))) tmp = x / y; else tmp = -2.0 + ((2.0 + (2.0 / z)) / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(x / y), $MachinePrecision], -5e+198], N[Not[LessEqual[N[(x / y), $MachinePrecision], 1e+130]], $MachinePrecision]], N[(x / y), $MachinePrecision], N[(-2.0 + N[(N[(2.0 + N[(2.0 / z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} \leq -5 \cdot 10^{+198} \lor \neg \left(\frac{x}{y} \leq 10^{+130}\right):\\
\;\;\;\;\frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;-2 + \frac{2 + \frac{2}{z}}{t}\\
\end{array}
\end{array}
if (/.f64 x y) < -5.00000000000000049e198 or 1.0000000000000001e130 < (/.f64 x y) Initial program 90.2%
Taylor expanded in x around inf 87.2%
if -5.00000000000000049e198 < (/.f64 x y) < 1.0000000000000001e130Initial program 88.0%
Taylor expanded in x around inf 72.0%
*-commutative72.0%
associate-/r*74.8%
associate-*l/74.8%
*-commutative74.8%
div-sub74.8%
sub-neg74.8%
*-inverses74.8%
metadata-eval74.8%
distribute-lft-in74.8%
metadata-eval74.8%
associate-*r/74.8%
metadata-eval74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in x around 0 89.6%
sub-neg89.6%
metadata-eval89.6%
+-commutative89.6%
*-commutative89.6%
associate-/r*89.7%
associate-*r/89.7%
*-commutative89.7%
associate-/l*89.6%
metadata-eval89.6%
associate-*r/89.6%
distribute-lft-in89.6%
associate-*r/89.6%
metadata-eval89.6%
associate-*l/89.7%
*-lft-identity89.7%
Simplified89.7%
Final simplification89.1%
(FPCore (x y z t) :precision binary64 (if (or (<= (/ x y) -8.5e+49) (not (<= (/ x y) 1.05e+28))) (/ x y) (+ (/ 2.0 t) -2.0)))
double code(double x, double y, double z, double t) {
double tmp;
if (((x / y) <= -8.5e+49) || !((x / y) <= 1.05e+28)) {
tmp = x / y;
} else {
tmp = (2.0 / t) + -2.0;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (((x / y) <= (-8.5d+49)) .or. (.not. ((x / y) <= 1.05d+28))) then
tmp = x / y
else
tmp = (2.0d0 / t) + (-2.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((x / y) <= -8.5e+49) || !((x / y) <= 1.05e+28)) {
tmp = x / y;
} else {
tmp = (2.0 / t) + -2.0;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((x / y) <= -8.5e+49) or not ((x / y) <= 1.05e+28): tmp = x / y else: tmp = (2.0 / t) + -2.0 return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(x / y) <= -8.5e+49) || !(Float64(x / y) <= 1.05e+28)) tmp = Float64(x / y); else tmp = Float64(Float64(2.0 / t) + -2.0); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((x / y) <= -8.5e+49) || ~(((x / y) <= 1.05e+28))) tmp = x / y; else tmp = (2.0 / t) + -2.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(x / y), $MachinePrecision], -8.5e+49], N[Not[LessEqual[N[(x / y), $MachinePrecision], 1.05e+28]], $MachinePrecision]], N[(x / y), $MachinePrecision], N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} \leq -8.5 \cdot 10^{+49} \lor \neg \left(\frac{x}{y} \leq 1.05 \cdot 10^{+28}\right):\\
\;\;\;\;\frac{x}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{t} + -2\\
\end{array}
\end{array}
if (/.f64 x y) < -8.4999999999999996e49 or 1.04999999999999995e28 < (/.f64 x y) Initial program 88.7%
Taylor expanded in x around inf 64.9%
if -8.4999999999999996e49 < (/.f64 x y) < 1.04999999999999995e28Initial program 88.3%
Taylor expanded in x around inf 67.3%
*-commutative67.3%
associate-/r*70.9%
associate-*l/70.9%
*-commutative70.9%
div-sub70.9%
sub-neg70.9%
*-inverses70.9%
metadata-eval70.9%
distribute-lft-in70.9%
metadata-eval70.9%
associate-*r/70.9%
metadata-eval70.9%
*-commutative70.9%
Simplified70.9%
Taylor expanded in x around 0 97.6%
sub-neg97.6%
metadata-eval97.6%
+-commutative97.6%
*-commutative97.6%
associate-/r*97.7%
associate-*r/97.7%
*-commutative97.7%
associate-/l*97.6%
metadata-eval97.6%
associate-*r/97.6%
distribute-lft-in97.6%
associate-*r/97.6%
metadata-eval97.6%
associate-*l/97.7%
*-lft-identity97.7%
Simplified97.7%
Taylor expanded in z around inf 57.2%
Final simplification60.4%
(FPCore (x y z t) :precision binary64 (if (<= (/ x y) -7.8e+49) (/ x y) (if (<= (/ x y) 0.72) (+ (/ 2.0 t) -2.0) (- (/ x y) 2.0))))
double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -7.8e+49) {
tmp = x / y;
} else if ((x / y) <= 0.72) {
tmp = (2.0 / t) + -2.0;
} else {
tmp = (x / y) - 2.0;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((x / y) <= (-7.8d+49)) then
tmp = x / y
else if ((x / y) <= 0.72d0) then
tmp = (2.0d0 / t) + (-2.0d0)
else
tmp = (x / y) - 2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((x / y) <= -7.8e+49) {
tmp = x / y;
} else if ((x / y) <= 0.72) {
tmp = (2.0 / t) + -2.0;
} else {
tmp = (x / y) - 2.0;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (x / y) <= -7.8e+49: tmp = x / y elif (x / y) <= 0.72: tmp = (2.0 / t) + -2.0 else: tmp = (x / y) - 2.0 return tmp
function code(x, y, z, t) tmp = 0.0 if (Float64(x / y) <= -7.8e+49) tmp = Float64(x / y); elseif (Float64(x / y) <= 0.72) tmp = Float64(Float64(2.0 / t) + -2.0); else tmp = Float64(Float64(x / y) - 2.0); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((x / y) <= -7.8e+49) tmp = x / y; elseif ((x / y) <= 0.72) tmp = (2.0 / t) + -2.0; else tmp = (x / y) - 2.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[N[(x / y), $MachinePrecision], -7.8e+49], N[(x / y), $MachinePrecision], If[LessEqual[N[(x / y), $MachinePrecision], 0.72], N[(N[(2.0 / t), $MachinePrecision] + -2.0), $MachinePrecision], N[(N[(x / y), $MachinePrecision] - 2.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x}{y} \leq -7.8 \cdot 10^{+49}:\\
\;\;\;\;\frac{x}{y}\\
\mathbf{elif}\;\frac{x}{y} \leq 0.72:\\
\;\;\;\;\frac{2}{t} + -2\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y} - 2\\
\end{array}
\end{array}
if (/.f64 x y) < -7.8000000000000002e49Initial program 88.1%
Taylor expanded in x around inf 61.5%
if -7.8000000000000002e49 < (/.f64 x y) < 0.71999999999999997Initial program 88.6%
Taylor expanded in x around inf 66.7%
*-commutative66.7%
associate-/r*69.9%
associate-*l/69.9%
*-commutative69.9%
div-sub69.9%
sub-neg69.9%
*-inverses69.9%
metadata-eval69.9%
distribute-lft-in69.9%
metadata-eval69.9%
associate-*r/69.9%
metadata-eval69.9%
*-commutative69.9%
Simplified69.9%
Taylor expanded in x around 0 98.3%
sub-neg98.3%
metadata-eval98.3%
+-commutative98.3%
*-commutative98.3%
associate-/r*98.3%
associate-*r/98.3%
*-commutative98.3%
associate-/l*98.3%
metadata-eval98.3%
associate-*r/98.3%
distribute-lft-in98.2%
associate-*r/98.2%
metadata-eval98.2%
associate-*l/98.3%
*-lft-identity98.3%
Simplified98.3%
Taylor expanded in z around inf 58.7%
if 0.71999999999999997 < (/.f64 x y) Initial program 88.4%
Taylor expanded in t around inf 64.2%
Final simplification60.6%
(FPCore (x y z t) :precision binary64 (if (<= t -19000000.0) -2.0 (if (<= t 3.2e+14) (/ 2.0 t) -2.0)))
double code(double x, double y, double z, double t) {
double tmp;
if (t <= -19000000.0) {
tmp = -2.0;
} else if (t <= 3.2e+14) {
tmp = 2.0 / t;
} else {
tmp = -2.0;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (t <= (-19000000.0d0)) then
tmp = -2.0d0
else if (t <= 3.2d+14) then
tmp = 2.0d0 / t
else
tmp = -2.0d0
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (t <= -19000000.0) {
tmp = -2.0;
} else if (t <= 3.2e+14) {
tmp = 2.0 / t;
} else {
tmp = -2.0;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if t <= -19000000.0: tmp = -2.0 elif t <= 3.2e+14: tmp = 2.0 / t else: tmp = -2.0 return tmp
function code(x, y, z, t) tmp = 0.0 if (t <= -19000000.0) tmp = -2.0; elseif (t <= 3.2e+14) tmp = Float64(2.0 / t); else tmp = -2.0; end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (t <= -19000000.0) tmp = -2.0; elseif (t <= 3.2e+14) tmp = 2.0 / t; else tmp = -2.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[t, -19000000.0], -2.0, If[LessEqual[t, 3.2e+14], N[(2.0 / t), $MachinePrecision], -2.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -19000000:\\
\;\;\;\;-2\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{+14}:\\
\;\;\;\;\frac{2}{t}\\
\mathbf{else}:\\
\;\;\;\;-2\\
\end{array}
\end{array}
if t < -1.9e7 or 3.2e14 < t Initial program 75.5%
Taylor expanded in t around inf 76.6%
Taylor expanded in x around 0 42.4%
if -1.9e7 < t < 3.2e14Initial program 99.0%
Taylor expanded in t around 0 78.6%
associate-*r/78.6%
metadata-eval78.6%
Simplified78.6%
Taylor expanded in z around inf 35.0%
(FPCore (x y z t) :precision binary64 -2.0)
double code(double x, double y, double z, double t) {
return -2.0;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = -2.0d0
end function
public static double code(double x, double y, double z, double t) {
return -2.0;
}
def code(x, y, z, t): return -2.0
function code(x, y, z, t) return -2.0 end
function tmp = code(x, y, z, t) tmp = -2.0; end
code[x_, y_, z_, t_] := -2.0
\begin{array}{l}
\\
-2
\end{array}
Initial program 88.5%
Taylor expanded in t around inf 47.7%
Taylor expanded in x around 0 20.3%
(FPCore (x y z t) :precision binary64 (- (/ (+ (/ 2.0 z) 2.0) t) (- 2.0 (/ x y))))
double code(double x, double y, double z, double t) {
return (((2.0 / z) + 2.0) / t) - (2.0 - (x / y));
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (((2.0d0 / z) + 2.0d0) / t) - (2.0d0 - (x / y))
end function
public static double code(double x, double y, double z, double t) {
return (((2.0 / z) + 2.0) / t) - (2.0 - (x / y));
}
def code(x, y, z, t): return (((2.0 / z) + 2.0) / t) - (2.0 - (x / y))
function code(x, y, z, t) return Float64(Float64(Float64(Float64(2.0 / z) + 2.0) / t) - Float64(2.0 - Float64(x / y))) end
function tmp = code(x, y, z, t) tmp = (((2.0 / z) + 2.0) / t) - (2.0 - (x / y)); end
code[x_, y_, z_, t_] := N[(N[(N[(N[(2.0 / z), $MachinePrecision] + 2.0), $MachinePrecision] / t), $MachinePrecision] - N[(2.0 - N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{2}{z} + 2}{t} - \left(2 - \frac{x}{y}\right)
\end{array}
herbie shell --seed 2024087
(FPCore (x y z t)
:name "Data.HashTable.ST.Basic:computeOverhead from hashtables-1.2.0.2"
:precision binary64
:alt
(- (/ (+ (/ 2.0 z) 2.0) t) (- 2.0 (/ x y)))
(+ (/ x y) (/ (+ 2.0 (* (* z 2.0) (- 1.0 t))) (* t z))))