
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 23 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* c (* t (fma (- z) (/ b t) j))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = c * (t * fma(-z, (b / t), j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(c * Float64(t * fma(Float64(-z), Float64(b / t), j))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(c * N[(t * N[((-z) * N[(b / t), $MachinePrecision] + j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot \mathsf{fma}\left(-z, \frac{b}{t}, j\right)\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 93.4%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
cancel-sign-subN/A
associate-*r*N/A
mul-1-negN/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
lower-fma.f64N/A
Simplified34.8%
Taylor expanded in c around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6449.7
Simplified49.7%
Taylor expanded in t around inf
+-commutativeN/A
mul-1-negN/A
neg-sub0N/A
associate-+l-N/A
unsub-negN/A
mul-1-negN/A
+-commutativeN/A
neg-sub0N/A
lower-*.f64N/A
neg-sub0N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
associate-+l-N/A
neg-sub0N/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
Simplified53.6%
Final simplification85.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -6.7e-19)
(fma (* z (- c)) b (fma b (* a i) (* y (fma (- j) i (* x z)))))
(if (<= y 6.2e+167)
(+
(* j (- (* t c) (* y i)))
(fma z (fma c (- b) (* x y)) (* a (fma t (- x) (* b i)))))
(fma y (fma j (- i) (* x z)) (- (* b (* z c)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -6.7e-19) {
tmp = fma((z * -c), b, fma(b, (a * i), (y * fma(-j, i, (x * z)))));
} else if (y <= 6.2e+167) {
tmp = (j * ((t * c) - (y * i))) + fma(z, fma(c, -b, (x * y)), (a * fma(t, -x, (b * i))));
} else {
tmp = fma(y, fma(j, -i, (x * z)), -(b * (z * c)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -6.7e-19) tmp = fma(Float64(z * Float64(-c)), b, fma(b, Float64(a * i), Float64(y * fma(Float64(-j), i, Float64(x * z))))); elseif (y <= 6.2e+167) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + fma(z, fma(c, Float64(-b), Float64(x * y)), Float64(a * fma(t, Float64(-x), Float64(b * i))))); else tmp = fma(y, fma(j, Float64(-i), Float64(x * z)), Float64(-Float64(b * Float64(z * c)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -6.7e-19], N[(N[(z * (-c)), $MachinePrecision] * b + N[(b * N[(a * i), $MachinePrecision] + N[(y * N[((-j) * i + N[(x * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.2e+167], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(c * (-b) + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(j * (-i) + N[(x * z), $MachinePrecision]), $MachinePrecision] + (-N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision])), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.7 \cdot 10^{-19}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \left(-c\right), b, \mathsf{fma}\left(b, a \cdot i, y \cdot \mathsf{fma}\left(-j, i, x \cdot z\right)\right)\right)\\
\mathbf{elif}\;y \leq 6.2 \cdot 10^{+167}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + \mathsf{fma}\left(z, \mathsf{fma}\left(c, -b, x \cdot y\right), a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(j, -i, x \cdot z\right), -b \cdot \left(z \cdot c\right)\right)\\
\end{array}
\end{array}
if y < -6.69999999999999998e-19Initial program 64.6%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
Simplified80.3%
lift-neg.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
lift-neg.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
distribute-rgt-inN/A
associate-+l+N/A
lower-fma.f64N/A
lower-*.f64N/A
Applied egg-rr82.9%
if -6.69999999999999998e-19 < y < 6.1999999999999999e167Initial program 82.1%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
cancel-sign-subN/A
associate-*r*N/A
mul-1-negN/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
lower-fma.f64N/A
Simplified85.3%
if 6.1999999999999999e167 < y Initial program 67.9%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
Simplified76.2%
Taylor expanded in c around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6488.2
Simplified88.2%
Final simplification84.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= j -1.04e+124)
(* j (fma c t (- (* y i))))
(if (<= j -5.7e+32)
(+ (* y (* x z)) (* j (* t c)))
(if (<= j -6e-221)
(* (* z b) (fma a (/ i z) (- c)))
(if (<= j 2.8e-16)
(* x (- (* y z) (* t a)))
(* j (* (fma i (/ y t) (- c)) (- t))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -1.04e+124) {
tmp = j * fma(c, t, -(y * i));
} else if (j <= -5.7e+32) {
tmp = (y * (x * z)) + (j * (t * c));
} else if (j <= -6e-221) {
tmp = (z * b) * fma(a, (i / z), -c);
} else if (j <= 2.8e-16) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = j * (fma(i, (y / t), -c) * -t);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -1.04e+124) tmp = Float64(j * fma(c, t, Float64(-Float64(y * i)))); elseif (j <= -5.7e+32) tmp = Float64(Float64(y * Float64(x * z)) + Float64(j * Float64(t * c))); elseif (j <= -6e-221) tmp = Float64(Float64(z * b) * fma(a, Float64(i / z), Float64(-c))); elseif (j <= 2.8e-16) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); else tmp = Float64(j * Float64(fma(i, Float64(y / t), Float64(-c)) * Float64(-t))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -1.04e+124], N[(j * N[(c * t + (-N[(y * i), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -5.7e+32], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -6e-221], N[(N[(z * b), $MachinePrecision] * N[(a * N[(i / z), $MachinePrecision] + (-c)), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.8e-16], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(j * N[(N[(i * N[(y / t), $MachinePrecision] + (-c)), $MachinePrecision] * (-t)), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -1.04 \cdot 10^{+124}:\\
\;\;\;\;j \cdot \mathsf{fma}\left(c, t, -y \cdot i\right)\\
\mathbf{elif}\;j \leq -5.7 \cdot 10^{+32}:\\
\;\;\;\;y \cdot \left(x \cdot z\right) + j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;j \leq -6 \cdot 10^{-221}:\\
\;\;\;\;\left(z \cdot b\right) \cdot \mathsf{fma}\left(a, \frac{i}{z}, -c\right)\\
\mathbf{elif}\;j \leq 2.8 \cdot 10^{-16}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(\mathsf{fma}\left(i, \frac{y}{t}, -c\right) \cdot \left(-t\right)\right)\\
\end{array}
\end{array}
if j < -1.03999999999999994e124Initial program 75.5%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6479.6
Simplified79.6%
if -1.03999999999999994e124 < j < -5.7e32Initial program 80.3%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6476.2
Simplified76.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6464.9
Simplified64.9%
if -5.7e32 < j < -6.0000000000000003e-221Initial program 63.4%
Taylor expanded in z around inf
Simplified58.8%
Taylor expanded in b around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6457.7
Simplified57.7%
if -6.0000000000000003e-221 < j < 2.8000000000000001e-16Initial program 83.1%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6456.9
Simplified56.9%
if 2.8000000000000001e-16 < j Initial program 73.0%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6467.0
Simplified67.0%
Taylor expanded in t around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6470.2
Simplified70.2%
Final simplification64.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -7.8e+164)
(* t (fma j c (* x (- a))))
(if (<= c -8e-230)
(fma (* z (- c)) b (fma b (* a i) (* y (fma (- j) i (* x z)))))
(if (<= c 1.8e+215)
(fma x (- (* y z) (* t a)) (* i (fma j (- y) (* a b))))
(* c (fma j t (* z (- b))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (c <= -7.8e+164) {
tmp = t * fma(j, c, (x * -a));
} else if (c <= -8e-230) {
tmp = fma((z * -c), b, fma(b, (a * i), (y * fma(-j, i, (x * z)))));
} else if (c <= 1.8e+215) {
tmp = fma(x, ((y * z) - (t * a)), (i * fma(j, -y, (a * b))));
} else {
tmp = c * fma(j, t, (z * -b));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -7.8e+164) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (c <= -8e-230) tmp = fma(Float64(z * Float64(-c)), b, fma(b, Float64(a * i), Float64(y * fma(Float64(-j), i, Float64(x * z))))); elseif (c <= 1.8e+215) tmp = fma(x, Float64(Float64(y * z) - Float64(t * a)), Float64(i * fma(j, Float64(-y), Float64(a * b)))); else tmp = Float64(c * fma(j, t, Float64(z * Float64(-b)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -7.8e+164], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -8e-230], N[(N[(z * (-c)), $MachinePrecision] * b + N[(b * N[(a * i), $MachinePrecision] + N[(y * N[((-j) * i + N[(x * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.8e+215], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision] + N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -7.8 \cdot 10^{+164}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;c \leq -8 \cdot 10^{-230}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \left(-c\right), b, \mathsf{fma}\left(b, a \cdot i, y \cdot \mathsf{fma}\left(-j, i, x \cdot z\right)\right)\right)\\
\mathbf{elif}\;c \leq 1.8 \cdot 10^{+215}:\\
\;\;\;\;\mathsf{fma}\left(x, y \cdot z - t \cdot a, i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\end{array}
\end{array}
if c < -7.79999999999999971e164Initial program 73.3%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6468.2
Simplified68.2%
if -7.79999999999999971e164 < c < -8.00000000000000037e-230Initial program 73.7%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
Simplified71.9%
lift-neg.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
lift-neg.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-fma.f64N/A
distribute-rgt-inN/A
associate-+l+N/A
lower-fma.f64N/A
lower-*.f64N/A
Applied egg-rr74.2%
if -8.00000000000000037e-230 < c < 1.79999999999999987e215Initial program 79.4%
Taylor expanded in c around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
cancel-sign-subN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
Simplified76.2%
if 1.79999999999999987e215 < c Initial program 67.3%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6487.9
Simplified87.9%
Final simplification75.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -7.8e+164)
(* t (fma j c (* x (- a))))
(if (<= c -1.8e-84)
(fma y (fma j (- i) (* x z)) (* b (fma c (- z) (* a i))))
(if (<= c 1.8e+215)
(fma x (- (* y z) (* t a)) (* i (fma j (- y) (* a b))))
(* c (fma j t (* z (- b))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (c <= -7.8e+164) {
tmp = t * fma(j, c, (x * -a));
} else if (c <= -1.8e-84) {
tmp = fma(y, fma(j, -i, (x * z)), (b * fma(c, -z, (a * i))));
} else if (c <= 1.8e+215) {
tmp = fma(x, ((y * z) - (t * a)), (i * fma(j, -y, (a * b))));
} else {
tmp = c * fma(j, t, (z * -b));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -7.8e+164) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (c <= -1.8e-84) tmp = fma(y, fma(j, Float64(-i), Float64(x * z)), Float64(b * fma(c, Float64(-z), Float64(a * i)))); elseif (c <= 1.8e+215) tmp = fma(x, Float64(Float64(y * z) - Float64(t * a)), Float64(i * fma(j, Float64(-y), Float64(a * b)))); else tmp = Float64(c * fma(j, t, Float64(z * Float64(-b)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -7.8e+164], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -1.8e-84], N[(y * N[(j * (-i) + N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.8e+215], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision] + N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -7.8 \cdot 10^{+164}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;c \leq -1.8 \cdot 10^{-84}:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(j, -i, x \cdot z\right), b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\right)\\
\mathbf{elif}\;c \leq 1.8 \cdot 10^{+215}:\\
\;\;\;\;\mathsf{fma}\left(x, y \cdot z - t \cdot a, i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\end{array}
\end{array}
if c < -7.79999999999999971e164Initial program 73.3%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6468.2
Simplified68.2%
if -7.79999999999999971e164 < c < -1.80000000000000002e-84Initial program 73.9%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
Simplified77.6%
if -1.80000000000000002e-84 < c < 1.79999999999999987e215Initial program 78.1%
Taylor expanded in c around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
cancel-sign-subN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
Simplified74.0%
if 1.79999999999999987e215 < c Initial program 67.3%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6487.9
Simplified87.9%
Final simplification75.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma x (- (* y z) (* t a)) (* i (fma j (- y) (* a b))))))
(if (<= x -2.7e-17)
t_1
(if (<= x 3.9e-138) (- (* j (- (* t c) (* y i))) (* c (* z b))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(x, ((y * z) - (t * a)), (i * fma(j, -y, (a * b))));
double tmp;
if (x <= -2.7e-17) {
tmp = t_1;
} else if (x <= 3.9e-138) {
tmp = (j * ((t * c) - (y * i))) - (c * (z * b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(x, Float64(Float64(y * z) - Float64(t * a)), Float64(i * fma(j, Float64(-y), Float64(a * b)))) tmp = 0.0 if (x <= -2.7e-17) tmp = t_1; elseif (x <= 3.9e-138) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) - Float64(c * Float64(z * b))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision] + N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.7e-17], t$95$1, If[LessEqual[x, 3.9e-138], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(c * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(x, y \cdot z - t \cdot a, i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\right)\\
\mathbf{if}\;x \leq -2.7 \cdot 10^{-17}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 3.9 \cdot 10^{-138}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) - c \cdot \left(z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.7000000000000001e-17 or 3.8999999999999999e-138 < x Initial program 79.8%
Taylor expanded in c around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
cancel-sign-subN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
Simplified75.1%
if -2.7000000000000001e-17 < x < 3.8999999999999999e-138Initial program 67.8%
Taylor expanded in c around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6467.1
Simplified67.1%
Final simplification72.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (fma c t (- (* y i))))))
(if (<= j -1.04e+124)
t_1
(if (<= j -5.7e+32)
(+ (* y (* x z)) (* j (* t c)))
(if (<= j -6e-221)
(* (* z b) (fma a (/ i z) (- c)))
(if (<= j 2.8e-16) (* x (- (* y z) (* t a))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * fma(c, t, -(y * i));
double tmp;
if (j <= -1.04e+124) {
tmp = t_1;
} else if (j <= -5.7e+32) {
tmp = (y * (x * z)) + (j * (t * c));
} else if (j <= -6e-221) {
tmp = (z * b) * fma(a, (i / z), -c);
} else if (j <= 2.8e-16) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * fma(c, t, Float64(-Float64(y * i)))) tmp = 0.0 if (j <= -1.04e+124) tmp = t_1; elseif (j <= -5.7e+32) tmp = Float64(Float64(y * Float64(x * z)) + Float64(j * Float64(t * c))); elseif (j <= -6e-221) tmp = Float64(Float64(z * b) * fma(a, Float64(i / z), Float64(-c))); elseif (j <= 2.8e-16) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(c * t + (-N[(y * i), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.04e+124], t$95$1, If[LessEqual[j, -5.7e+32], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -6e-221], N[(N[(z * b), $MachinePrecision] * N[(a * N[(i / z), $MachinePrecision] + (-c)), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.8e-16], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \mathsf{fma}\left(c, t, -y \cdot i\right)\\
\mathbf{if}\;j \leq -1.04 \cdot 10^{+124}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -5.7 \cdot 10^{+32}:\\
\;\;\;\;y \cdot \left(x \cdot z\right) + j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;j \leq -6 \cdot 10^{-221}:\\
\;\;\;\;\left(z \cdot b\right) \cdot \mathsf{fma}\left(a, \frac{i}{z}, -c\right)\\
\mathbf{elif}\;j \leq 2.8 \cdot 10^{-16}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.03999999999999994e124 or 2.8000000000000001e-16 < j Initial program 74.0%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6472.2
Simplified72.2%
if -1.03999999999999994e124 < j < -5.7e32Initial program 80.3%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6476.2
Simplified76.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6464.9
Simplified64.9%
if -5.7e32 < j < -6.0000000000000003e-221Initial program 63.4%
Taylor expanded in z around inf
Simplified58.8%
Taylor expanded in b around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6457.7
Simplified57.7%
if -6.0000000000000003e-221 < j < 2.8000000000000001e-16Initial program 83.1%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6456.9
Simplified56.9%
Final simplification63.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* z b) (fma a (/ i z) (- c)))))
(if (<= b -1.1e+117)
t_1
(if (<= b 9.2e+103) (+ (* j (- (* t c) (* y i))) (* y (* x z))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (z * b) * fma(a, (i / z), -c);
double tmp;
if (b <= -1.1e+117) {
tmp = t_1;
} else if (b <= 9.2e+103) {
tmp = (j * ((t * c) - (y * i))) + (y * (x * z));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(z * b) * fma(a, Float64(i / z), Float64(-c))) tmp = 0.0 if (b <= -1.1e+117) tmp = t_1; elseif (b <= 9.2e+103) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(y * Float64(x * z))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(z * b), $MachinePrecision] * N[(a * N[(i / z), $MachinePrecision] + (-c)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.1e+117], t$95$1, If[LessEqual[b, 9.2e+103], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot b\right) \cdot \mathsf{fma}\left(a, \frac{i}{z}, -c\right)\\
\mathbf{if}\;b \leq -1.1 \cdot 10^{+117}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 9.2 \cdot 10^{+103}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.10000000000000007e117 or 9.20000000000000034e103 < b Initial program 68.9%
Taylor expanded in z around inf
Simplified65.0%
Taylor expanded in b around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6471.9
Simplified71.9%
if -1.10000000000000007e117 < b < 9.20000000000000034e103Initial program 79.1%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6463.1
Simplified63.1%
Final simplification66.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (fma c t (- (* y i))))))
(if (<= j -1.04e+124)
t_1
(if (<= j -2.6e+30)
(+ (* y (* x z)) (* j (* t c)))
(if (<= j 2.3e-298)
(* a (fma t (- x) (* b i)))
(if (<= j 2.8e-16) (* x (- (* y z) (* t a))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * fma(c, t, -(y * i));
double tmp;
if (j <= -1.04e+124) {
tmp = t_1;
} else if (j <= -2.6e+30) {
tmp = (y * (x * z)) + (j * (t * c));
} else if (j <= 2.3e-298) {
tmp = a * fma(t, -x, (b * i));
} else if (j <= 2.8e-16) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * fma(c, t, Float64(-Float64(y * i)))) tmp = 0.0 if (j <= -1.04e+124) tmp = t_1; elseif (j <= -2.6e+30) tmp = Float64(Float64(y * Float64(x * z)) + Float64(j * Float64(t * c))); elseif (j <= 2.3e-298) tmp = Float64(a * fma(t, Float64(-x), Float64(b * i))); elseif (j <= 2.8e-16) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(c * t + (-N[(y * i), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.04e+124], t$95$1, If[LessEqual[j, -2.6e+30], N[(N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.3e-298], N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.8e-16], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \mathsf{fma}\left(c, t, -y \cdot i\right)\\
\mathbf{if}\;j \leq -1.04 \cdot 10^{+124}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -2.6 \cdot 10^{+30}:\\
\;\;\;\;y \cdot \left(x \cdot z\right) + j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;j \leq 2.3 \cdot 10^{-298}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{elif}\;j \leq 2.8 \cdot 10^{-16}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.03999999999999994e124 or 2.8000000000000001e-16 < j Initial program 74.0%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6472.2
Simplified72.2%
if -1.03999999999999994e124 < j < -2.59999999999999988e30Initial program 81.0%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6477.1
Simplified77.1%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6466.2
Simplified66.2%
if -2.59999999999999988e30 < j < 2.3000000000000001e-298Initial program 71.3%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.3
Simplified52.3%
if 2.3000000000000001e-298 < j < 2.8000000000000001e-16Initial program 81.5%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6461.4
Simplified61.4%
Final simplification63.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (fma t (- x) (* b i)))))
(if (<= a -1.3e+33)
t_1
(if (<= a -2.06e-287)
(* b (fma a i (* z (- c))))
(if (<= a 3.2e-220)
(* c (* t j))
(if (<= a 9e-78) (* z (* x y)) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * fma(t, -x, (b * i));
double tmp;
if (a <= -1.3e+33) {
tmp = t_1;
} else if (a <= -2.06e-287) {
tmp = b * fma(a, i, (z * -c));
} else if (a <= 3.2e-220) {
tmp = c * (t * j);
} else if (a <= 9e-78) {
tmp = z * (x * y);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * fma(t, Float64(-x), Float64(b * i))) tmp = 0.0 if (a <= -1.3e+33) tmp = t_1; elseif (a <= -2.06e-287) tmp = Float64(b * fma(a, i, Float64(z * Float64(-c)))); elseif (a <= 3.2e-220) tmp = Float64(c * Float64(t * j)); elseif (a <= 9e-78) tmp = Float64(z * Float64(x * y)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.3e+33], t$95$1, If[LessEqual[a, -2.06e-287], N[(b * N[(a * i + N[(z * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.2e-220], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 9e-78], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{if}\;a \leq -1.3 \cdot 10^{+33}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -2.06 \cdot 10^{-287}:\\
\;\;\;\;b \cdot \mathsf{fma}\left(a, i, z \cdot \left(-c\right)\right)\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{-220}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;a \leq 9 \cdot 10^{-78}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -1.2999999999999999e33 or 9e-78 < a Initial program 71.2%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.8
Simplified56.8%
if -1.2999999999999999e33 < a < -2.0599999999999999e-287Initial program 77.7%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
cancel-sign-subN/A
associate-*r*N/A
mul-1-negN/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
lower-fma.f64N/A
Simplified71.9%
Taylor expanded in b around inf
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6441.4
Simplified41.4%
if -2.0599999999999999e-287 < a < 3.20000000000000005e-220Initial program 89.8%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6476.8
Simplified76.8%
Taylor expanded in y around 0
lower-*.f64N/A
*-commutativeN/A
lower-*.f6457.2
Simplified57.2%
if 3.20000000000000005e-220 < a < 9e-78Initial program 81.1%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6463.0
Simplified63.0%
Taylor expanded in c around 0
lower-*.f6453.6
Simplified53.6%
Final simplification51.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- y) (* a b)))))
(if (<= i -3.2e+100)
t_1
(if (<= i -6e-16)
(* t (fma j c (* x (- a))))
(if (<= i 42000000.0) (* x (fma a (- t) (* y z))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * fma(j, -y, (a * b));
double tmp;
if (i <= -3.2e+100) {
tmp = t_1;
} else if (i <= -6e-16) {
tmp = t * fma(j, c, (x * -a));
} else if (i <= 42000000.0) {
tmp = x * fma(a, -t, (y * z));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(-y), Float64(a * b))) tmp = 0.0 if (i <= -3.2e+100) tmp = t_1; elseif (i <= -6e-16) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (i <= 42000000.0) tmp = Float64(x * fma(a, Float64(-t), Float64(y * z))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -3.2e+100], t$95$1, If[LessEqual[i, -6e-16], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 42000000.0], N[(x * N[(a * (-t) + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{if}\;i \leq -3.2 \cdot 10^{+100}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -6 \cdot 10^{-16}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;i \leq 42000000:\\
\;\;\;\;x \cdot \mathsf{fma}\left(a, -t, y \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -3.1999999999999999e100 or 4.2e7 < i Initial program 70.4%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6468.0
Simplified68.0%
if -3.1999999999999999e100 < i < -5.99999999999999987e-16Initial program 79.1%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6466.1
Simplified66.1%
if -5.99999999999999987e-16 < i < 4.2e7Initial program 80.2%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
cancel-sign-subN/A
associate-*r*N/A
mul-1-negN/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
lower-fma.f64N/A
Simplified79.4%
Taylor expanded in x around inf
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6453.8
Simplified53.8%
Final simplification61.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- y) (* a b)))))
(if (<= i -3.2e+100)
t_1
(if (<= i -6e-16)
(* t (fma j c (* x (- a))))
(if (<= i 42000000.0) (* x (- (* y z) (* t a))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * fma(j, -y, (a * b));
double tmp;
if (i <= -3.2e+100) {
tmp = t_1;
} else if (i <= -6e-16) {
tmp = t * fma(j, c, (x * -a));
} else if (i <= 42000000.0) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(-y), Float64(a * b))) tmp = 0.0 if (i <= -3.2e+100) tmp = t_1; elseif (i <= -6e-16) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (i <= 42000000.0) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -3.2e+100], t$95$1, If[LessEqual[i, -6e-16], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 42000000.0], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{if}\;i \leq -3.2 \cdot 10^{+100}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -6 \cdot 10^{-16}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;i \leq 42000000:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -3.1999999999999999e100 or 4.2e7 < i Initial program 70.4%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6468.0
Simplified68.0%
if -3.1999999999999999e100 < i < -5.99999999999999987e-16Initial program 79.1%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6466.1
Simplified66.1%
if -5.99999999999999987e-16 < i < 4.2e7Initial program 80.2%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6453.8
Simplified53.8%
Final simplification61.4%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.12e+134)
(* i (* y (- j)))
(if (<= i -4.2e+82)
(* i (* a b))
(if (<= i -6.5e-16)
(* j (* t c))
(if (<= i 4.2e+42) (* y (* x z)) (* a (* b i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.12e+134) {
tmp = i * (y * -j);
} else if (i <= -4.2e+82) {
tmp = i * (a * b);
} else if (i <= -6.5e-16) {
tmp = j * (t * c);
} else if (i <= 4.2e+42) {
tmp = y * (x * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-1.12d+134)) then
tmp = i * (y * -j)
else if (i <= (-4.2d+82)) then
tmp = i * (a * b)
else if (i <= (-6.5d-16)) then
tmp = j * (t * c)
else if (i <= 4.2d+42) then
tmp = y * (x * z)
else
tmp = a * (b * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.12e+134) {
tmp = i * (y * -j);
} else if (i <= -4.2e+82) {
tmp = i * (a * b);
} else if (i <= -6.5e-16) {
tmp = j * (t * c);
} else if (i <= 4.2e+42) {
tmp = y * (x * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -1.12e+134: tmp = i * (y * -j) elif i <= -4.2e+82: tmp = i * (a * b) elif i <= -6.5e-16: tmp = j * (t * c) elif i <= 4.2e+42: tmp = y * (x * z) else: tmp = a * (b * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.12e+134) tmp = Float64(i * Float64(y * Float64(-j))); elseif (i <= -4.2e+82) tmp = Float64(i * Float64(a * b)); elseif (i <= -6.5e-16) tmp = Float64(j * Float64(t * c)); elseif (i <= 4.2e+42) tmp = Float64(y * Float64(x * z)); else tmp = Float64(a * Float64(b * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -1.12e+134) tmp = i * (y * -j); elseif (i <= -4.2e+82) tmp = i * (a * b); elseif (i <= -6.5e-16) tmp = j * (t * c); elseif (i <= 4.2e+42) tmp = y * (x * z); else tmp = a * (b * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.12e+134], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -4.2e+82], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -6.5e-16], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 4.2e+42], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.12 \cdot 10^{+134}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\mathbf{elif}\;i \leq -4.2 \cdot 10^{+82}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;i \leq -6.5 \cdot 10^{-16}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;i \leq 4.2 \cdot 10^{+42}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\end{array}
\end{array}
if i < -1.12000000000000007e134Initial program 73.4%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6462.3
Simplified62.3%
Taylor expanded in c around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6450.1
Simplified50.1%
if -1.12000000000000007e134 < i < -4.2e82Initial program 64.7%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6465.8
Simplified65.8%
Taylor expanded in t around 0
lower-*.f64N/A
lower-*.f6452.7
Simplified52.7%
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f6452.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6452.7
Applied egg-rr52.7%
if -4.2e82 < i < -6.50000000000000011e-16Initial program 86.4%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6450.5
Simplified50.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6450.4
Simplified50.4%
if -6.50000000000000011e-16 < i < 4.19999999999999991e42Initial program 81.2%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.7
Simplified50.7%
Taylor expanded in c around 0
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6436.0
Simplified36.0%
if 4.19999999999999991e42 < i Initial program 64.8%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.6
Simplified50.6%
Taylor expanded in t around 0
lower-*.f64N/A
lower-*.f6445.3
Simplified45.3%
Final simplification42.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -5.2e-111)
(* z (* x y))
(if (<= y 2e-260)
(- (* x (* t a)))
(if (<= y 7.5e+98) (* j (* t c)) (* i (* y (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -5.2e-111) {
tmp = z * (x * y);
} else if (y <= 2e-260) {
tmp = -(x * (t * a));
} else if (y <= 7.5e+98) {
tmp = j * (t * c);
} else {
tmp = i * (y * -j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (y <= (-5.2d-111)) then
tmp = z * (x * y)
else if (y <= 2d-260) then
tmp = -(x * (t * a))
else if (y <= 7.5d+98) then
tmp = j * (t * c)
else
tmp = i * (y * -j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -5.2e-111) {
tmp = z * (x * y);
} else if (y <= 2e-260) {
tmp = -(x * (t * a));
} else if (y <= 7.5e+98) {
tmp = j * (t * c);
} else {
tmp = i * (y * -j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -5.2e-111: tmp = z * (x * y) elif y <= 2e-260: tmp = -(x * (t * a)) elif y <= 7.5e+98: tmp = j * (t * c) else: tmp = i * (y * -j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -5.2e-111) tmp = Float64(z * Float64(x * y)); elseif (y <= 2e-260) tmp = Float64(-Float64(x * Float64(t * a))); elseif (y <= 7.5e+98) tmp = Float64(j * Float64(t * c)); else tmp = Float64(i * Float64(y * Float64(-j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -5.2e-111) tmp = z * (x * y); elseif (y <= 2e-260) tmp = -(x * (t * a)); elseif (y <= 7.5e+98) tmp = j * (t * c); else tmp = i * (y * -j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -5.2e-111], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2e-260], (-N[(x * N[(t * a), $MachinePrecision]), $MachinePrecision]), If[LessEqual[y, 7.5e+98], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.2 \cdot 10^{-111}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;y \leq 2 \cdot 10^{-260}:\\
\;\;\;\;-x \cdot \left(t \cdot a\right)\\
\mathbf{elif}\;y \leq 7.5 \cdot 10^{+98}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if y < -5.19999999999999965e-111Initial program 66.4%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.9
Simplified54.9%
Taylor expanded in c around 0
lower-*.f6444.1
Simplified44.1%
if -5.19999999999999965e-111 < y < 1.99999999999999992e-260Initial program 86.0%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6462.1
Simplified62.1%
lift-neg.f64N/A
lift-*.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-outN/A
distribute-lft-neg-outN/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6460.0
Applied egg-rr60.0%
Taylor expanded in b around 0
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6444.0
Simplified44.0%
if 1.99999999999999992e-260 < y < 7.50000000000000036e98Initial program 84.5%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6444.5
Simplified44.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6435.8
Simplified35.8%
if 7.50000000000000036e98 < y Initial program 65.5%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6449.4
Simplified49.4%
Taylor expanded in c around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6443.0
Simplified43.0%
Final simplification41.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (fma c t (- (* y i))))))
(if (<= j -5.8e+22)
t_1
(if (<= j 3.3e+35) (* a (fma t (- x) (* b i))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * fma(c, t, -(y * i));
double tmp;
if (j <= -5.8e+22) {
tmp = t_1;
} else if (j <= 3.3e+35) {
tmp = a * fma(t, -x, (b * i));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * fma(c, t, Float64(-Float64(y * i)))) tmp = 0.0 if (j <= -5.8e+22) tmp = t_1; elseif (j <= 3.3e+35) tmp = Float64(a * fma(t, Float64(-x), Float64(b * i))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(c * t + (-N[(y * i), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -5.8e+22], t$95$1, If[LessEqual[j, 3.3e+35], N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \mathsf{fma}\left(c, t, -y \cdot i\right)\\
\mathbf{if}\;j \leq -5.8 \cdot 10^{+22}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 3.3 \cdot 10^{+35}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -5.8e22 or 3.3000000000000002e35 < j Initial program 77.0%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6468.6
Simplified68.6%
if -5.8e22 < j < 3.3000000000000002e35Initial program 74.3%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.8
Simplified48.8%
Final simplification57.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (fma j t (* z (- b))))))
(if (<= c -8.2e+139)
t_1
(if (<= c 1.75e+143) (* i (fma j (- y) (* a b))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * fma(j, t, (z * -b));
double tmp;
if (c <= -8.2e+139) {
tmp = t_1;
} else if (c <= 1.75e+143) {
tmp = i * fma(j, -y, (a * b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * fma(j, t, Float64(z * Float64(-b)))) tmp = 0.0 if (c <= -8.2e+139) tmp = t_1; elseif (c <= 1.75e+143) tmp = Float64(i * fma(j, Float64(-y), Float64(a * b))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -8.2e+139], t$95$1, If[LessEqual[c, 1.75e+143], N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\mathbf{if}\;c \leq -8.2 \cdot 10^{+139}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 1.75 \cdot 10^{+143}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -8.2000000000000004e139 or 1.75000000000000004e143 < c Initial program 68.6%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6472.5
Simplified72.5%
if -8.2000000000000004e139 < c < 1.75000000000000004e143Initial program 78.5%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.2
Simplified49.2%
Final simplification56.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (fma t (- x) (* b i)))))
(if (<= a -750000000000.0)
t_1
(if (<= a 1.25e-73) (* c (fma j t (* z (- b)))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * fma(t, -x, (b * i));
double tmp;
if (a <= -750000000000.0) {
tmp = t_1;
} else if (a <= 1.25e-73) {
tmp = c * fma(j, t, (z * -b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * fma(t, Float64(-x), Float64(b * i))) tmp = 0.0 if (a <= -750000000000.0) tmp = t_1; elseif (a <= 1.25e-73) tmp = Float64(c * fma(j, t, Float64(z * Float64(-b)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -750000000000.0], t$95$1, If[LessEqual[a, 1.25e-73], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{if}\;a \leq -750000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.25 \cdot 10^{-73}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -7.5e11 or 1.25e-73 < a Initial program 71.4%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.4
Simplified56.4%
if -7.5e11 < a < 1.25e-73Initial program 80.1%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6449.0
Simplified49.0%
Final simplification52.9%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= y -7.2e-7) (* z (* x y)) (if (<= y 2.95e+122) (* a (fma t (- x) (* b i))) (* (* y i) (- j)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -7.2e-7) {
tmp = z * (x * y);
} else if (y <= 2.95e+122) {
tmp = a * fma(t, -x, (b * i));
} else {
tmp = (y * i) * -j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -7.2e-7) tmp = Float64(z * Float64(x * y)); elseif (y <= 2.95e+122) tmp = Float64(a * fma(t, Float64(-x), Float64(b * i))); else tmp = Float64(Float64(y * i) * Float64(-j)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -7.2e-7], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.95e+122], N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * i), $MachinePrecision] * (-j)), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -7.2 \cdot 10^{-7}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;y \leq 2.95 \cdot 10^{+122}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(-j\right)\\
\end{array}
\end{array}
if y < -7.19999999999999989e-7Initial program 65.0%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6458.0
Simplified58.0%
Taylor expanded in c around 0
lower-*.f6448.3
Simplified48.3%
if -7.19999999999999989e-7 < y < 2.95000000000000016e122Initial program 81.5%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.8
Simplified47.8%
if 2.95000000000000016e122 < y Initial program 71.8%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6452.9
Simplified52.9%
Taylor expanded in c around 0
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6447.3
Simplified47.3%
Final simplification47.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.3e+101)
(* (* y i) (- j))
(if (<= i -6.5e-16)
(* j (* t c))
(if (<= i 4.2e+42) (* y (* x z)) (* a (* b i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.3e+101) {
tmp = (y * i) * -j;
} else if (i <= -6.5e-16) {
tmp = j * (t * c);
} else if (i <= 4.2e+42) {
tmp = y * (x * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-1.3d+101)) then
tmp = (y * i) * -j
else if (i <= (-6.5d-16)) then
tmp = j * (t * c)
else if (i <= 4.2d+42) then
tmp = y * (x * z)
else
tmp = a * (b * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.3e+101) {
tmp = (y * i) * -j;
} else if (i <= -6.5e-16) {
tmp = j * (t * c);
} else if (i <= 4.2e+42) {
tmp = y * (x * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -1.3e+101: tmp = (y * i) * -j elif i <= -6.5e-16: tmp = j * (t * c) elif i <= 4.2e+42: tmp = y * (x * z) else: tmp = a * (b * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.3e+101) tmp = Float64(Float64(y * i) * Float64(-j)); elseif (i <= -6.5e-16) tmp = Float64(j * Float64(t * c)); elseif (i <= 4.2e+42) tmp = Float64(y * Float64(x * z)); else tmp = Float64(a * Float64(b * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -1.3e+101) tmp = (y * i) * -j; elseif (i <= -6.5e-16) tmp = j * (t * c); elseif (i <= 4.2e+42) tmp = y * (x * z); else tmp = a * (b * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.3e+101], N[(N[(y * i), $MachinePrecision] * (-j)), $MachinePrecision], If[LessEqual[i, -6.5e-16], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 4.2e+42], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.3 \cdot 10^{+101}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(-j\right)\\
\mathbf{elif}\;i \leq -6.5 \cdot 10^{-16}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;i \leq 4.2 \cdot 10^{+42}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\end{array}
\end{array}
if i < -1.3e101Initial program 72.4%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6459.9
Simplified59.9%
Taylor expanded in c around 0
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6447.9
Simplified47.9%
if -1.3e101 < i < -6.50000000000000011e-16Initial program 80.0%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6443.5
Simplified43.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6440.1
Simplified40.1%
if -6.50000000000000011e-16 < i < 4.19999999999999991e42Initial program 81.2%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.7
Simplified50.7%
Taylor expanded in c around 0
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6436.0
Simplified36.0%
if 4.19999999999999991e42 < i Initial program 64.8%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.6
Simplified50.6%
Taylor expanded in t around 0
lower-*.f64N/A
lower-*.f6445.3
Simplified45.3%
Final simplification41.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (* b i))))
(if (<= i -1.2e+84)
t_1
(if (<= i -6.5e-16)
(* j (* t c))
(if (<= i 4.2e+42) (* y (* x z)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double tmp;
if (i <= -1.2e+84) {
tmp = t_1;
} else if (i <= -6.5e-16) {
tmp = j * (t * c);
} else if (i <= 4.2e+42) {
tmp = y * (x * z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = a * (b * i)
if (i <= (-1.2d+84)) then
tmp = t_1
else if (i <= (-6.5d-16)) then
tmp = j * (t * c)
else if (i <= 4.2d+42) then
tmp = y * (x * z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double tmp;
if (i <= -1.2e+84) {
tmp = t_1;
} else if (i <= -6.5e-16) {
tmp = j * (t * c);
} else if (i <= 4.2e+42) {
tmp = y * (x * z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * (b * i) tmp = 0 if i <= -1.2e+84: tmp = t_1 elif i <= -6.5e-16: tmp = j * (t * c) elif i <= 4.2e+42: tmp = y * (x * z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(b * i)) tmp = 0.0 if (i <= -1.2e+84) tmp = t_1; elseif (i <= -6.5e-16) tmp = Float64(j * Float64(t * c)); elseif (i <= 4.2e+42) tmp = Float64(y * Float64(x * z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * (b * i); tmp = 0.0; if (i <= -1.2e+84) tmp = t_1; elseif (i <= -6.5e-16) tmp = j * (t * c); elseif (i <= 4.2e+42) tmp = y * (x * z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.2e+84], t$95$1, If[LessEqual[i, -6.5e-16], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 4.2e+42], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i\right)\\
\mathbf{if}\;i \leq -1.2 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -6.5 \cdot 10^{-16}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;i \leq 4.2 \cdot 10^{+42}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.2e84 or 4.19999999999999991e42 < i Initial program 68.3%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.7
Simplified49.7%
Taylor expanded in t around 0
lower-*.f64N/A
lower-*.f6442.4
Simplified42.4%
if -1.2e84 < i < -6.50000000000000011e-16Initial program 86.4%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6450.5
Simplified50.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6450.4
Simplified50.4%
if -6.50000000000000011e-16 < i < 4.19999999999999991e42Initial program 81.2%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.7
Simplified50.7%
Taylor expanded in c around 0
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6436.0
Simplified36.0%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= j -4.5e+30) (* c (* t j)) (if (<= j 4.2e+171) (* a (* b i)) (* j (* t c)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -4.5e+30) {
tmp = c * (t * j);
} else if (j <= 4.2e+171) {
tmp = a * (b * i);
} else {
tmp = j * (t * c);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (j <= (-4.5d+30)) then
tmp = c * (t * j)
else if (j <= 4.2d+171) then
tmp = a * (b * i)
else
tmp = j * (t * c)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -4.5e+30) {
tmp = c * (t * j);
} else if (j <= 4.2e+171) {
tmp = a * (b * i);
} else {
tmp = j * (t * c);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if j <= -4.5e+30: tmp = c * (t * j) elif j <= 4.2e+171: tmp = a * (b * i) else: tmp = j * (t * c) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -4.5e+30) tmp = Float64(c * Float64(t * j)); elseif (j <= 4.2e+171) tmp = Float64(a * Float64(b * i)); else tmp = Float64(j * Float64(t * c)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (j <= -4.5e+30) tmp = c * (t * j); elseif (j <= 4.2e+171) tmp = a * (b * i); else tmp = j * (t * c); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -4.5e+30], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 4.2e+171], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -4.5 \cdot 10^{+30}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;j \leq 4.2 \cdot 10^{+171}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\end{array}
\end{array}
if j < -4.49999999999999995e30Initial program 77.6%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6478.1
Simplified78.1%
Taylor expanded in y around 0
lower-*.f64N/A
*-commutativeN/A
lower-*.f6439.0
Simplified39.0%
if -4.49999999999999995e30 < j < 4.2000000000000003e171Initial program 74.7%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.6
Simplified48.6%
Taylor expanded in t around 0
lower-*.f64N/A
lower-*.f6429.8
Simplified29.8%
if 4.2000000000000003e171 < j Initial program 75.3%
Taylor expanded in j around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6483.6
Simplified83.6%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f6447.5
Simplified47.5%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* c (* t j)))) (if (<= j -4.5e+30) t_1 (if (<= j 4.2e+171) (* a (* b i)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (j <= -4.5e+30) {
tmp = t_1;
} else if (j <= 4.2e+171) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * (t * j)
if (j <= (-4.5d+30)) then
tmp = t_1
else if (j <= 4.2d+171) then
tmp = a * (b * i)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (j <= -4.5e+30) {
tmp = t_1;
} else if (j <= 4.2e+171) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * (t * j) tmp = 0 if j <= -4.5e+30: tmp = t_1 elif j <= 4.2e+171: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(t * j)) tmp = 0.0 if (j <= -4.5e+30) tmp = t_1; elseif (j <= 4.2e+171) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * (t * j); tmp = 0.0; if (j <= -4.5e+30) tmp = t_1; elseif (j <= 4.2e+171) tmp = a * (b * i); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -4.5e+30], t$95$1, If[LessEqual[j, 4.2e+171], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;j \leq -4.5 \cdot 10^{+30}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 4.2 \cdot 10^{+171}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -4.49999999999999995e30 or 4.2000000000000003e171 < j Initial program 77.0%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6478.4
Simplified78.4%
Taylor expanded in y around 0
lower-*.f64N/A
*-commutativeN/A
lower-*.f6441.2
Simplified41.2%
if -4.49999999999999995e30 < j < 4.2000000000000003e171Initial program 74.7%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.6
Simplified48.6%
Taylor expanded in t around 0
lower-*.f64N/A
lower-*.f6429.8
Simplified29.8%
(FPCore (x y z t a b c i j) :precision binary64 (* a (* b i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = a * (b * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
def code(x, y, z, t, a, b, c, i, j): return a * (b * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(a * Float64(b * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = a * (b * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \left(b \cdot i\right)
\end{array}
Initial program 75.5%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6440.1
Simplified40.1%
Taylor expanded in t around 0
lower-*.f64N/A
lower-*.f6424.9
Simplified24.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) 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 a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024212
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:alt
(! :herbie-platform default (if (< t -1015122364899489/125000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -942510763643697/2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (if (< t -238547917063487/3125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 10535888557455487/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))