
(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 24 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
(-
(* (- (* c t) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b)))))
(if (<= t_1 5e+272)
(fma
(fma (- a) t (* z y))
x
(fma (- (fma (- a) i (* c z))) b (* (fma (- y) i (* c t)) j)))
(if (<= t_1 INFINITY)
(*
(-
(fma
j
t
(/ (fma (fma (- y) j (* b a)) i (* (fma (- t) a (* z y)) x)) c))
(* b z))
c)
(* (fma (- i) y (fma t c (/ (* (fma (- b) c (* y x)) z) j))) j)))))
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) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b));
double tmp;
if (t_1 <= 5e+272) {
tmp = fma(fma(-a, t, (z * y)), x, fma(-fma(-a, i, (c * z)), b, (fma(-y, i, (c * t)) * j)));
} else if (t_1 <= ((double) INFINITY)) {
tmp = (fma(j, t, (fma(fma(-y, j, (b * a)), i, (fma(-t, a, (z * y)) * x)) / c)) - (b * z)) * c;
} else {
tmp = fma(-i, y, fma(t, c, ((fma(-b, c, (y * x)) * z) / j))) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b))) tmp = 0.0 if (t_1 <= 5e+272) tmp = fma(fma(Float64(-a), t, Float64(z * y)), x, fma(Float64(-fma(Float64(-a), i, Float64(c * z))), b, Float64(fma(Float64(-y), i, Float64(c * t)) * j))); elseif (t_1 <= Inf) tmp = Float64(Float64(fma(j, t, Float64(fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(fma(Float64(-t), a, Float64(z * y)) * x)) / c)) - Float64(b * z)) * c); else tmp = Float64(fma(Float64(-i), y, fma(t, c, Float64(Float64(fma(Float64(-b), c, Float64(y * x)) * z) / j))) * j); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 5e+272], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x + N[((-N[((-a) * i + N[(c * z), $MachinePrecision]), $MachinePrecision]) * b + N[(N[((-y) * i + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(j * t + N[(N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], N[(N[((-i) * y + N[(t * c + N[(N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot t - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\right)\\
\mathbf{if}\;t\_1 \leq 5 \cdot 10^{+272}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-a, t, z \cdot y\right), x, \mathsf{fma}\left(-\mathsf{fma}\left(-a, i, c \cdot z\right), b, \mathsf{fma}\left(-y, i, c \cdot t\right) \cdot j\right)\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\left(\mathsf{fma}\left(j, t, \frac{\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)}{c}\right) - b \cdot z\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, \mathsf{fma}\left(t, c, \frac{\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z}{j}\right)\right) \cdot j\\
\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)))) < 4.99999999999999973e272Initial program 94.0%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites94.0%
if 4.99999999999999973e272 < (+.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 81.3%
Taylor expanded in c around inf
Applied rewrites91.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 a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.8%
Taylor expanded in j around inf
Applied rewrites75.3%
Final simplification90.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<=
(-
(* (- (* c t) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b)))
INFINITY)
(fma
(fma (- a) t (* z y))
x
(fma (- (fma (- a) i (* c z))) b (* (fma (- y) i (* c t)) j)))
(* (fma (- i) y (fma t c (/ (* (fma (- b) c (* y x)) z) j))) j)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (((((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b))) <= ((double) INFINITY)) {
tmp = fma(fma(-a, t, (z * y)), x, fma(-fma(-a, i, (c * z)), b, (fma(-y, i, (c * t)) * j)));
} else {
tmp = fma(-i, y, fma(t, c, ((fma(-b, c, (y * x)) * z) / j))) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b))) <= Inf) tmp = fma(fma(Float64(-a), t, Float64(z * y)), x, fma(Float64(-fma(Float64(-a), i, Float64(c * z))), b, Float64(fma(Float64(-y), i, Float64(c * t)) * j))); else tmp = Float64(fma(Float64(-i), y, fma(t, c, Float64(Float64(fma(Float64(-b), c, Float64(y * x)) * z) / j))) * j); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x + N[((-N[((-a) * i + N[(c * z), $MachinePrecision]), $MachinePrecision]) * b + N[(N[((-y) * i + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-i) * y + N[(t * c + N[(N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(c \cdot t - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\right) \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-a, t, z \cdot y\right), x, \mathsf{fma}\left(-\mathsf{fma}\left(-a, i, c \cdot z\right), b, \mathsf{fma}\left(-y, i, c \cdot t\right) \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, \mathsf{fma}\left(t, c, \frac{\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z}{j}\right)\right) \cdot j\\
\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 90.6%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites90.6%
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 a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.8%
Taylor expanded in j around inf
Applied rewrites75.3%
Final simplification88.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) a (* j c)) t)))
(if (<= t -2.4e+179)
t_1
(if (<= t 1.72e+202)
(fma
(fma (- x) t (* i b))
a
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j)))
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, a, (j * c)) * t;
double tmp;
if (t <= -2.4e+179) {
tmp = t_1;
} else if (t <= 1.72e+202) {
tmp = fma(fma(-x, t, (i * b)), a, fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -2.4e+179) tmp = t_1; elseif (t <= 1.72e+202) tmp = fma(fma(Float64(-x), t, Float64(i * b)), a, fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -2.4e+179], t$95$1, If[LessEqual[t, 1.72e+202], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{if}\;t \leq -2.4 \cdot 10^{+179}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.72 \cdot 10^{+202}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, t, i \cdot b\right), a, \mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.40000000000000013e179 or 1.71999999999999996e202 < t Initial program 61.2%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6481.8
Applied rewrites81.8%
if -2.40000000000000013e179 < t < 1.71999999999999996e202Initial program 78.5%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites88.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- c) b (* y x)) z (* (fma (- t) x (* i b)) a))))
(if (<= z -1.8e+144)
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j))
(if (<= z -9.5e+16)
t_1
(if (<= z 5.7e+143)
(fma
(fma (- a) t (* z y))
x
(fma (* i a) b (* (fma (- y) i (* c t)) j)))
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(fma(-c, b, (y * x)), z, (fma(-t, x, (i * b)) * a));
double tmp;
if (z <= -1.8e+144) {
tmp = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
} else if (z <= -9.5e+16) {
tmp = t_1;
} else if (z <= 5.7e+143) {
tmp = fma(fma(-a, t, (z * y)), x, fma((i * a), b, (fma(-y, i, (c * t)) * j)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-c), b, Float64(y * x)), z, Float64(fma(Float64(-t), x, Float64(i * b)) * a)) tmp = 0.0 if (z <= -1.8e+144) tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); elseif (z <= -9.5e+16) tmp = t_1; elseif (z <= 5.7e+143) tmp = fma(fma(Float64(-a), t, Float64(z * y)), x, fma(Float64(i * a), b, Float64(fma(Float64(-y), i, Float64(c * t)) * j))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-t) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.8e+144], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -9.5e+16], t$95$1, If[LessEqual[z, 5.7e+143], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x + N[(N[(i * a), $MachinePrecision] * b + N[(N[((-y) * i + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-c, b, y \cdot x\right), z, \mathsf{fma}\left(-t, x, i \cdot b\right) \cdot a\right)\\
\mathbf{if}\;z \leq -1.8 \cdot 10^{+144}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{elif}\;z \leq -9.5 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 5.7 \cdot 10^{+143}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-a, t, z \cdot y\right), x, \mathsf{fma}\left(i \cdot a, b, \mathsf{fma}\left(-y, i, c \cdot t\right) \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.7999999999999999e144Initial program 65.1%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites86.6%
if -1.7999999999999999e144 < z < -9.5e16 or 5.70000000000000022e143 < z Initial program 67.7%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites90.3%
Taylor expanded in j around 0
Applied rewrites88.9%
if -9.5e16 < z < 5.70000000000000022e143Initial program 79.5%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites84.3%
Taylor expanded in z around 0
*-commutativeN/A
lower-*.f6477.7
Applied rewrites77.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -3.7e-120)
(fma (fma (- c) b (* y x)) z (* (fma (- t) x (* i b)) a))
(if (<= x 6.7e-68)
(* (- (fma j t (/ (* (fma (- j) y (* b a)) i) c)) (* b z)) c)
(fma (fma (- y) j (* b a)) i (* (fma (- t) a (* z y)) x)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -3.7e-120) {
tmp = fma(fma(-c, b, (y * x)), z, (fma(-t, x, (i * b)) * a));
} else if (x <= 6.7e-68) {
tmp = (fma(j, t, ((fma(-j, y, (b * a)) * i) / c)) - (b * z)) * c;
} else {
tmp = fma(fma(-y, j, (b * a)), i, (fma(-t, a, (z * y)) * x));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -3.7e-120) tmp = fma(fma(Float64(-c), b, Float64(y * x)), z, Float64(fma(Float64(-t), x, Float64(i * b)) * a)); elseif (x <= 6.7e-68) tmp = Float64(Float64(fma(j, t, Float64(Float64(fma(Float64(-j), y, Float64(b * a)) * i) / c)) - Float64(b * z)) * c); else tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(fma(Float64(-t), a, Float64(z * y)) * x)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -3.7e-120], N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-t) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 6.7e-68], N[(N[(N[(j * t + N[(N[(N[((-j) * y + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] - N[(b * z), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.7 \cdot 10^{-120}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, b, y \cdot x\right), z, \mathsf{fma}\left(-t, x, i \cdot b\right) \cdot a\right)\\
\mathbf{elif}\;x \leq 6.7 \cdot 10^{-68}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, t, \frac{\mathsf{fma}\left(-j, y, b \cdot a\right) \cdot i}{c}\right) - b \cdot z\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\end{array}
\end{array}
if x < -3.70000000000000001e-120Initial program 73.7%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites80.9%
Taylor expanded in j around 0
Applied rewrites74.4%
if -3.70000000000000001e-120 < x < 6.6999999999999996e-68Initial program 70.5%
Taylor expanded in c around inf
Applied rewrites70.6%
Taylor expanded in x around 0
Applied rewrites79.2%
if 6.6999999999999996e-68 < x Initial program 82.9%
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
+-commutativeN/A
Applied rewrites80.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) a (* j c)) t)))
(if (<= t -4.2e+130)
t_1
(if (<= t -7.5e-46)
(* (fma (- x) z (* j i)) (- y))
(if (<= t 8.3e-224)
(* (fma (- b) c (* y x)) z)
(if (<= t 1.55e+47) (* (* (- (/ (* b a) y) j) y) 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 = fma(-x, a, (j * c)) * t;
double tmp;
if (t <= -4.2e+130) {
tmp = t_1;
} else if (t <= -7.5e-46) {
tmp = fma(-x, z, (j * i)) * -y;
} else if (t <= 8.3e-224) {
tmp = fma(-b, c, (y * x)) * z;
} else if (t <= 1.55e+47) {
tmp = ((((b * a) / y) - j) * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -4.2e+130) tmp = t_1; elseif (t <= -7.5e-46) tmp = Float64(fma(Float64(-x), z, Float64(j * i)) * Float64(-y)); elseif (t <= 8.3e-224) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (t <= 1.55e+47) tmp = Float64(Float64(Float64(Float64(Float64(b * a) / y) - j) * y) * i); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -4.2e+130], t$95$1, If[LessEqual[t, -7.5e-46], N[(N[((-x) * z + N[(j * i), $MachinePrecision]), $MachinePrecision] * (-y)), $MachinePrecision], If[LessEqual[t, 8.3e-224], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 1.55e+47], N[(N[(N[(N[(N[(b * a), $MachinePrecision] / y), $MachinePrecision] - j), $MachinePrecision] * y), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{if}\;t \leq -4.2 \cdot 10^{+130}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-46}:\\
\;\;\;\;\mathsf{fma}\left(-x, z, j \cdot i\right) \cdot \left(-y\right)\\
\mathbf{elif}\;t \leq 8.3 \cdot 10^{-224}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;t \leq 1.55 \cdot 10^{+47}:\\
\;\;\;\;\left(\left(\frac{b \cdot a}{y} - j\right) \cdot y\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -4.19999999999999981e130 or 1.55e47 < t Initial program 66.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6472.5
Applied rewrites72.5%
if -4.19999999999999981e130 < t < -7.50000000000000027e-46Initial program 76.6%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites76.6%
Taylor expanded in y around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6460.2
Applied rewrites60.2%
if -7.50000000000000027e-46 < t < 8.29999999999999999e-224Initial program 77.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.7
Applied rewrites60.7%
if 8.29999999999999999e-224 < t < 1.55e47Initial program 85.7%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/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.5
Applied rewrites56.5%
Taylor expanded in y around inf
Applied rewrites58.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -5.8e+75)
(* (fma (- z) b (* j t)) c)
(if (<= c 1.75e-47)
(fma (fma (- a) t (* z y)) x (* (* i b) a))
(if (<= c 8e+218)
(+ (* (* z x) y) (* (- (* c t) (* i y)) j))
(* (fma (- b) c (* y x)) z)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (c <= -5.8e+75) {
tmp = fma(-z, b, (j * t)) * c;
} else if (c <= 1.75e-47) {
tmp = fma(fma(-a, t, (z * y)), x, ((i * b) * a));
} else if (c <= 8e+218) {
tmp = ((z * x) * y) + (((c * t) - (i * y)) * j);
} else {
tmp = fma(-b, c, (y * x)) * z;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -5.8e+75) tmp = Float64(fma(Float64(-z), b, Float64(j * t)) * c); elseif (c <= 1.75e-47) tmp = fma(fma(Float64(-a), t, Float64(z * y)), x, Float64(Float64(i * b) * a)); elseif (c <= 8e+218) tmp = Float64(Float64(Float64(z * x) * y) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); else tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -5.8e+75], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[c, 1.75e-47], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x + N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 8e+218], N[(N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -5.8 \cdot 10^{+75}:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot t\right) \cdot c\\
\mathbf{elif}\;c \leq 1.75 \cdot 10^{-47}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-a, t, z \cdot y\right), x, \left(i \cdot b\right) \cdot a\right)\\
\mathbf{elif}\;c \leq 8 \cdot 10^{+218}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\end{array}
\end{array}
if c < -5.7999999999999997e75Initial program 68.4%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6474.3
Applied rewrites74.3%
if -5.7999999999999997e75 < c < 1.7499999999999999e-47Initial program 82.0%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.6%
Taylor expanded in z around 0
*-commutativeN/A
lower-*.f6474.4
Applied rewrites74.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6464.0
Applied rewrites64.0%
if 1.7499999999999999e-47 < c < 8.00000000000000066e218Initial program 69.1%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6461.9
Applied rewrites61.9%
if 8.00000000000000066e218 < c Initial program 61.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.8
Applied rewrites78.8%
Final simplification66.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -1.45e-161)
(fma (fma (- c) b (* y x)) z (* (fma (- t) x (* i b)) a))
(if (<= x 1.45e-45)
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j))
(fma (fma (- y) j (* b a)) i (* (fma (- t) a (* z y)) x)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -1.45e-161) {
tmp = fma(fma(-c, b, (y * x)), z, (fma(-t, x, (i * b)) * a));
} else if (x <= 1.45e-45) {
tmp = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
} else {
tmp = fma(fma(-y, j, (b * a)), i, (fma(-t, a, (z * y)) * x));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -1.45e-161) tmp = fma(fma(Float64(-c), b, Float64(y * x)), z, Float64(fma(Float64(-t), x, Float64(i * b)) * a)); elseif (x <= 1.45e-45) tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); else tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(fma(Float64(-t), a, Float64(z * y)) * x)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -1.45e-161], N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-t) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.45e-45], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.45 \cdot 10^{-161}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, b, y \cdot x\right), z, \mathsf{fma}\left(-t, x, i \cdot b\right) \cdot a\right)\\
\mathbf{elif}\;x \leq 1.45 \cdot 10^{-45}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\end{array}
\end{array}
if x < -1.45e-161Initial program 71.5%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites80.2%
Taylor expanded in j around 0
Applied rewrites73.2%
if -1.45e-161 < x < 1.45e-45Initial program 73.0%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites76.0%
if 1.45e-45 < x Initial program 83.2%
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
+-commutativeN/A
Applied rewrites80.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -6.8e+175)
(* (fma (- x) t (* i b)) a)
(if (<= a 1.05e-111)
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j))
(fma (fma (- c) b (* y x)) z (* (fma (- t) x (* i b)) a)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -6.8e+175) {
tmp = fma(-x, t, (i * b)) * a;
} else if (a <= 1.05e-111) {
tmp = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
} else {
tmp = fma(fma(-c, b, (y * x)), z, (fma(-t, x, (i * b)) * a));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -6.8e+175) tmp = Float64(fma(Float64(-x), t, Float64(i * b)) * a); elseif (a <= 1.05e-111) tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); else tmp = fma(fma(Float64(-c), b, Float64(y * x)), z, Float64(fma(Float64(-t), x, Float64(i * b)) * a)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -6.8e+175], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[a, 1.05e-111], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-t) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6.8 \cdot 10^{+175}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{elif}\;a \leq 1.05 \cdot 10^{-111}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, b, y \cdot x\right), z, \mathsf{fma}\left(-t, x, i \cdot b\right) \cdot a\right)\\
\end{array}
\end{array}
if a < -6.80000000000000056e175Initial program 55.1%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6477.8
Applied rewrites77.8%
if -6.80000000000000056e175 < a < 1.0499999999999999e-111Initial program 79.6%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites75.6%
if 1.0499999999999999e-111 < a Initial program 72.2%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites86.0%
Taylor expanded in j around 0
Applied rewrites72.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -4.8e+22)
(fma (* y x) z (* (fma (- i) y (* c t)) j))
(if (<= y 8.5e+43)
(fma (fma (- c) b (* y x)) z (* (fma (- t) x (* i b)) a))
(* (fma (- x) z (* j i)) (- y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -4.8e+22) {
tmp = fma((y * x), z, (fma(-i, y, (c * t)) * j));
} else if (y <= 8.5e+43) {
tmp = fma(fma(-c, b, (y * x)), z, (fma(-t, x, (i * b)) * a));
} else {
tmp = fma(-x, z, (j * i)) * -y;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -4.8e+22) tmp = fma(Float64(y * x), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); elseif (y <= 8.5e+43) tmp = fma(fma(Float64(-c), b, Float64(y * x)), z, Float64(fma(Float64(-t), x, Float64(i * b)) * a)); else tmp = Float64(fma(Float64(-x), z, Float64(j * i)) * Float64(-y)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -4.8e+22], N[(N[(y * x), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.5e+43], N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-t) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], N[(N[((-x) * z + N[(j * i), $MachinePrecision]), $MachinePrecision] * (-y)), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.8 \cdot 10^{+22}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{elif}\;y \leq 8.5 \cdot 10^{+43}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, b, y \cdot x\right), z, \mathsf{fma}\left(-t, x, i \cdot b\right) \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-x, z, j \cdot i\right) \cdot \left(-y\right)\\
\end{array}
\end{array}
if y < -4.8e22Initial program 66.2%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites65.1%
Taylor expanded in x around inf
Applied rewrites63.4%
if -4.8e22 < y < 8.5e43Initial program 81.4%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites87.7%
Taylor expanded in j around 0
Applied rewrites74.2%
if 8.5e43 < y Initial program 64.6%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites70.6%
Taylor expanded in y around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6474.4
Applied rewrites74.4%
Final simplification72.0%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -5.8e+75)
(* (fma (- z) b (* j t)) c)
(if (<= c 1.5e-47)
(fma (fma (- a) t (* z y)) x (* (* i b) a))
(if (<= c 8e+218)
(fma (* y x) z (* (fma (- i) y (* c t)) j))
(* (fma (- b) c (* y x)) z)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (c <= -5.8e+75) {
tmp = fma(-z, b, (j * t)) * c;
} else if (c <= 1.5e-47) {
tmp = fma(fma(-a, t, (z * y)), x, ((i * b) * a));
} else if (c <= 8e+218) {
tmp = fma((y * x), z, (fma(-i, y, (c * t)) * j));
} else {
tmp = fma(-b, c, (y * x)) * z;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -5.8e+75) tmp = Float64(fma(Float64(-z), b, Float64(j * t)) * c); elseif (c <= 1.5e-47) tmp = fma(fma(Float64(-a), t, Float64(z * y)), x, Float64(Float64(i * b) * a)); elseif (c <= 8e+218) tmp = fma(Float64(y * x), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); else tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -5.8e+75], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[c, 1.5e-47], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x + N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 8e+218], N[(N[(y * x), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -5.8 \cdot 10^{+75}:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot t\right) \cdot c\\
\mathbf{elif}\;c \leq 1.5 \cdot 10^{-47}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-a, t, z \cdot y\right), x, \left(i \cdot b\right) \cdot a\right)\\
\mathbf{elif}\;c \leq 8 \cdot 10^{+218}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\end{array}
\end{array}
if c < -5.7999999999999997e75Initial program 68.4%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6474.3
Applied rewrites74.3%
if -5.7999999999999997e75 < c < 1.50000000000000008e-47Initial program 82.0%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.6%
Taylor expanded in z around 0
*-commutativeN/A
lower-*.f6474.4
Applied rewrites74.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6464.0
Applied rewrites64.0%
if 1.50000000000000008e-47 < c < 8.00000000000000066e218Initial program 69.1%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites66.4%
Taylor expanded in x around inf
Applied rewrites61.9%
if 8.00000000000000066e218 < c Initial program 61.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.8
Applied rewrites78.8%
Final simplification66.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) a (* j c)) t)))
(if (<= t -4.2e+130)
t_1
(if (<= t -7.5e-46)
(* (fma (- x) z (* j i)) (- y))
(if (<= t 8.3e-224)
(* (fma (- b) c (* y x)) z)
(if (<= t 1.55e+47) (* (fma (- y) j (* b a)) 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 = fma(-x, a, (j * c)) * t;
double tmp;
if (t <= -4.2e+130) {
tmp = t_1;
} else if (t <= -7.5e-46) {
tmp = fma(-x, z, (j * i)) * -y;
} else if (t <= 8.3e-224) {
tmp = fma(-b, c, (y * x)) * z;
} else if (t <= 1.55e+47) {
tmp = fma(-y, j, (b * a)) * i;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -4.2e+130) tmp = t_1; elseif (t <= -7.5e-46) tmp = Float64(fma(Float64(-x), z, Float64(j * i)) * Float64(-y)); elseif (t <= 8.3e-224) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (t <= 1.55e+47) tmp = Float64(fma(Float64(-y), j, Float64(b * a)) * i); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -4.2e+130], t$95$1, If[LessEqual[t, -7.5e-46], N[(N[((-x) * z + N[(j * i), $MachinePrecision]), $MachinePrecision] * (-y)), $MachinePrecision], If[LessEqual[t, 8.3e-224], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 1.55e+47], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{if}\;t \leq -4.2 \cdot 10^{+130}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-46}:\\
\;\;\;\;\mathsf{fma}\left(-x, z, j \cdot i\right) \cdot \left(-y\right)\\
\mathbf{elif}\;t \leq 8.3 \cdot 10^{-224}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;t \leq 1.55 \cdot 10^{+47}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot a\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -4.19999999999999981e130 or 1.55e47 < t Initial program 66.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6472.5
Applied rewrites72.5%
if -4.19999999999999981e130 < t < -7.50000000000000027e-46Initial program 76.6%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites76.6%
Taylor expanded in y around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6460.2
Applied rewrites60.2%
if -7.50000000000000027e-46 < t < 8.29999999999999999e-224Initial program 77.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.7
Applied rewrites60.7%
if 8.29999999999999999e-224 < t < 1.55e47Initial program 85.7%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/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.5
Applied rewrites56.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) a (* j c)) t)))
(if (<= t -4.2e+130)
t_1
(if (<= t -7.5e-46)
(* (fma (- i) j (* z x)) y)
(if (<= t 8.3e-224)
(* (fma (- b) c (* y x)) z)
(if (<= t 1.55e+47) (* (fma (- y) j (* b a)) 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 = fma(-x, a, (j * c)) * t;
double tmp;
if (t <= -4.2e+130) {
tmp = t_1;
} else if (t <= -7.5e-46) {
tmp = fma(-i, j, (z * x)) * y;
} else if (t <= 8.3e-224) {
tmp = fma(-b, c, (y * x)) * z;
} else if (t <= 1.55e+47) {
tmp = fma(-y, j, (b * a)) * i;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -4.2e+130) tmp = t_1; elseif (t <= -7.5e-46) tmp = Float64(fma(Float64(-i), j, Float64(z * x)) * y); elseif (t <= 8.3e-224) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (t <= 1.55e+47) tmp = Float64(fma(Float64(-y), j, Float64(b * a)) * i); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -4.2e+130], t$95$1, If[LessEqual[t, -7.5e-46], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t, 8.3e-224], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 1.55e+47], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{if}\;t \leq -4.2 \cdot 10^{+130}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-46}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{elif}\;t \leq 8.3 \cdot 10^{-224}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;t \leq 1.55 \cdot 10^{+47}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot a\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -4.19999999999999981e130 or 1.55e47 < t Initial program 66.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6472.5
Applied rewrites72.5%
if -4.19999999999999981e130 < t < -7.50000000000000027e-46Initial program 76.6%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6457.8
Applied rewrites57.8%
if -7.50000000000000027e-46 < t < 8.29999999999999999e-224Initial program 77.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.7
Applied rewrites60.7%
if 8.29999999999999999e-224 < t < 1.55e47Initial program 85.7%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/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.5
Applied rewrites56.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) j (* z x)) y)) (t_2 (* (fma (- x) a (* j c)) t)))
(if (<= t -4.2e+130)
t_2
(if (<= t -7.5e-46)
t_1
(if (<= t 1.3e-224)
(* (fma (- b) c (* y x)) z)
(if (<= t 3e-14) 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 = fma(-i, j, (z * x)) * y;
double t_2 = fma(-x, a, (j * c)) * t;
double tmp;
if (t <= -4.2e+130) {
tmp = t_2;
} else if (t <= -7.5e-46) {
tmp = t_1;
} else if (t <= 1.3e-224) {
tmp = fma(-b, c, (y * x)) * z;
} else if (t <= 3e-14) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-i), j, Float64(z * x)) * y) t_2 = Float64(fma(Float64(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -4.2e+130) tmp = t_2; elseif (t <= -7.5e-46) tmp = t_1; elseif (t <= 1.3e-224) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (t <= 3e-14) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -4.2e+130], t$95$2, If[LessEqual[t, -7.5e-46], t$95$1, If[LessEqual[t, 1.3e-224], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 3e-14], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
t_2 := \mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{if}\;t \leq -4.2 \cdot 10^{+130}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-46}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{-224}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;t \leq 3 \cdot 10^{-14}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -4.19999999999999981e130 or 2.9999999999999998e-14 < t Initial program 67.8%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.6
Applied rewrites69.6%
if -4.19999999999999981e130 < t < -7.50000000000000027e-46 or 1.3000000000000001e-224 < t < 2.9999999999999998e-14Initial program 81.1%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6457.3
Applied rewrites57.3%
if -7.50000000000000027e-46 < t < 1.3000000000000001e-224Initial program 77.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.7
Applied rewrites60.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= b -6.8e+34)
(* (fma (- z) b (* j t)) c)
(if (<= b 1.5e-39)
(fma (* y x) z (* (fma (- i) y (* c t)) j))
(if (<= b 1.85e+101)
(* (fma (- x) t (* i b)) a)
(* (fma (- z) c (* i a)) b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -6.8e+34) {
tmp = fma(-z, b, (j * t)) * c;
} else if (b <= 1.5e-39) {
tmp = fma((y * x), z, (fma(-i, y, (c * t)) * j));
} else if (b <= 1.85e+101) {
tmp = fma(-x, t, (i * b)) * a;
} else {
tmp = fma(-z, c, (i * a)) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -6.8e+34) tmp = Float64(fma(Float64(-z), b, Float64(j * t)) * c); elseif (b <= 1.5e-39) tmp = fma(Float64(y * x), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); elseif (b <= 1.85e+101) tmp = Float64(fma(Float64(-x), t, Float64(i * b)) * a); else tmp = Float64(fma(Float64(-z), c, Float64(i * a)) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -6.8e+34], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[b, 1.5e-39], N[(N[(y * x), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.85e+101], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6.8 \cdot 10^{+34}:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot t\right) \cdot c\\
\mathbf{elif}\;b \leq 1.5 \cdot 10^{-39}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x, z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{elif}\;b \leq 1.85 \cdot 10^{+101}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\end{array}
\end{array}
if b < -6.7999999999999999e34Initial program 75.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6460.1
Applied rewrites60.1%
if -6.7999999999999999e34 < b < 1.50000000000000014e-39Initial program 75.2%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites70.0%
Taylor expanded in x around inf
Applied rewrites65.7%
if 1.50000000000000014e-39 < b < 1.8499999999999999e101Initial program 83.9%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.3
Applied rewrites76.3%
if 1.8499999999999999e101 < b Initial program 68.9%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.1
Applied rewrites69.1%
Final simplification66.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- z) c) b)))
(if (<= c -6.2e+75)
t_1
(if (<= c 1.05e-116)
(* (* z x) y)
(if (<= c 2e-35)
(* (* i b) a)
(if (<= c 3.4e+195) (* (* c t) j) 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 * c) * b;
double tmp;
if (c <= -6.2e+75) {
tmp = t_1;
} else if (c <= 1.05e-116) {
tmp = (z * x) * y;
} else if (c <= 2e-35) {
tmp = (i * b) * a;
} else if (c <= 3.4e+195) {
tmp = (c * t) * j;
} 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 = (-z * c) * b
if (c <= (-6.2d+75)) then
tmp = t_1
else if (c <= 1.05d-116) then
tmp = (z * x) * y
else if (c <= 2d-35) then
tmp = (i * b) * a
else if (c <= 3.4d+195) then
tmp = (c * t) * j
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 = (-z * c) * b;
double tmp;
if (c <= -6.2e+75) {
tmp = t_1;
} else if (c <= 1.05e-116) {
tmp = (z * x) * y;
} else if (c <= 2e-35) {
tmp = (i * b) * a;
} else if (c <= 3.4e+195) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-z * c) * b tmp = 0 if c <= -6.2e+75: tmp = t_1 elif c <= 1.05e-116: tmp = (z * x) * y elif c <= 2e-35: tmp = (i * b) * a elif c <= 3.4e+195: tmp = (c * t) * j else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-z) * c) * b) tmp = 0.0 if (c <= -6.2e+75) tmp = t_1; elseif (c <= 1.05e-116) tmp = Float64(Float64(z * x) * y); elseif (c <= 2e-35) tmp = Float64(Float64(i * b) * a); elseif (c <= 3.4e+195) tmp = Float64(Float64(c * t) * j); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-z * c) * b; tmp = 0.0; if (c <= -6.2e+75) tmp = t_1; elseif (c <= 1.05e-116) tmp = (z * x) * y; elseif (c <= 2e-35) tmp = (i * b) * a; elseif (c <= 3.4e+195) tmp = (c * t) * j; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[c, -6.2e+75], t$95$1, If[LessEqual[c, 1.05e-116], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[c, 2e-35], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[c, 3.4e+195], N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{if}\;c \leq -6.2 \cdot 10^{+75}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 1.05 \cdot 10^{-116}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;c \leq 2 \cdot 10^{-35}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;c \leq 3.4 \cdot 10^{+195}:\\
\;\;\;\;\left(c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -6.2000000000000002e75 or 3.4000000000000001e195 < c Initial program 67.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.8
Applied rewrites56.8%
Taylor expanded in x around 0
Applied rewrites57.7%
if -6.2000000000000002e75 < c < 1.05e-116Initial program 82.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6442.8
Applied rewrites42.8%
Taylor expanded in x around inf
Applied rewrites32.2%
Applied rewrites33.0%
if 1.05e-116 < c < 2.00000000000000002e-35Initial program 76.5%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.8
Applied rewrites51.8%
Taylor expanded in y around 0
Applied rewrites46.2%
if 2.00000000000000002e-35 < c < 3.4000000000000001e195Initial program 67.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6424.0
Applied rewrites24.0%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6461.3
Applied rewrites61.3%
Taylor expanded in y around 0
Applied rewrites41.6%
Final simplification42.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)))
(if (<= z -1.05e-65)
t_1
(if (<= z 4e-9)
(* (fma (- i) y (* c t)) j)
(if (<= z 1.25e+93) (* (fma (- i) j (* 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 = fma(-b, c, (y * x)) * z;
double tmp;
if (z <= -1.05e-65) {
tmp = t_1;
} else if (z <= 4e-9) {
tmp = fma(-i, y, (c * t)) * j;
} else if (z <= 1.25e+93) {
tmp = fma(-i, j, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), c, Float64(y * x)) * z) tmp = 0.0 if (z <= -1.05e-65) tmp = t_1; elseif (z <= 4e-9) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); elseif (z <= 1.25e+93) tmp = Float64(fma(Float64(-i), j, Float64(z * 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[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -1.05e-65], t$95$1, If[LessEqual[z, 4e-9], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[z, 1.25e+93], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{-65}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 4 \cdot 10^{-9}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{elif}\;z \leq 1.25 \cdot 10^{+93}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.05000000000000001e-65 or 1.25e93 < z Initial program 70.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6464.0
Applied rewrites64.0%
if -1.05000000000000001e-65 < z < 4.00000000000000025e-9Initial program 76.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6419.6
Applied rewrites19.6%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.1
Applied rewrites52.1%
if 4.00000000000000025e-9 < z < 1.25e93Initial program 94.8%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6465.7
Applied rewrites65.7%
Final simplification58.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)))
(if (<= z -3.2e-59)
t_1
(if (<= z 1.25e+93) (* (fma (- i) j (* 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 = fma(-b, c, (y * x)) * z;
double tmp;
if (z <= -3.2e-59) {
tmp = t_1;
} else if (z <= 1.25e+93) {
tmp = fma(-i, j, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), c, Float64(y * x)) * z) tmp = 0.0 if (z <= -3.2e-59) tmp = t_1; elseif (z <= 1.25e+93) tmp = Float64(fma(Float64(-i), j, Float64(z * 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[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -3.2e-59], t$95$1, If[LessEqual[z, 1.25e+93], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -3.2 \cdot 10^{-59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.25 \cdot 10^{+93}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.1999999999999999e-59 or 1.25e93 < z Initial program 70.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6464.0
Applied rewrites64.0%
if -3.1999999999999999e-59 < z < 1.25e93Initial program 78.9%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6442.2
Applied rewrites42.2%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= t -1.7e+181) (* (* c t) j) (if (<= t 1.05e+274) (* (fma (- b) c (* y x)) z) (* (* 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 (t <= -1.7e+181) {
tmp = (c * t) * j;
} else if (t <= 1.05e+274) {
tmp = fma(-b, c, (y * x)) * z;
} else {
tmp = (j * t) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (t <= -1.7e+181) tmp = Float64(Float64(c * t) * j); elseif (t <= 1.05e+274) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); else tmp = Float64(Float64(j * t) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[t, -1.7e+181], N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[t, 1.05e+274], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.7 \cdot 10^{+181}:\\
\;\;\;\;\left(c \cdot t\right) \cdot j\\
\mathbf{elif}\;t \leq 1.05 \cdot 10^{+274}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot t\right) \cdot c\\
\end{array}
\end{array}
if t < -1.70000000000000015e181Initial program 71.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6415.6
Applied rewrites15.6%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6472.0
Applied rewrites72.0%
Taylor expanded in y around 0
Applied rewrites72.0%
if -1.70000000000000015e181 < t < 1.05000000000000008e274Initial program 76.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6445.7
Applied rewrites45.7%
if 1.05000000000000008e274 < t Initial program 59.2%
Taylor expanded in c around inf
Applied rewrites83.1%
Taylor expanded in t around inf
Applied rewrites100.0%
Taylor expanded in x around 0
Applied rewrites51.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* c t) j)))
(if (<= c -3.6e+70)
t_1
(if (<= c 1.05e-116) (* (* z x) y) (if (<= c 2e-35) (* (* i b) 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 = (c * t) * j;
double tmp;
if (c <= -3.6e+70) {
tmp = t_1;
} else if (c <= 1.05e-116) {
tmp = (z * x) * y;
} else if (c <= 2e-35) {
tmp = (i * b) * a;
} 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 (c <= (-3.6d+70)) then
tmp = t_1
else if (c <= 1.05d-116) then
tmp = (z * x) * y
else if (c <= 2d-35) then
tmp = (i * b) * a
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 (c <= -3.6e+70) {
tmp = t_1;
} else if (c <= 1.05e-116) {
tmp = (z * x) * y;
} else if (c <= 2e-35) {
tmp = (i * b) * a;
} 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 c <= -3.6e+70: tmp = t_1 elif c <= 1.05e-116: tmp = (z * x) * y elif c <= 2e-35: tmp = (i * b) * a else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(c * t) * j) tmp = 0.0 if (c <= -3.6e+70) tmp = t_1; elseif (c <= 1.05e-116) tmp = Float64(Float64(z * x) * y); elseif (c <= 2e-35) tmp = Float64(Float64(i * b) * a); 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 (c <= -3.6e+70) tmp = t_1; elseif (c <= 1.05e-116) tmp = (z * x) * y; elseif (c <= 2e-35) tmp = (i * b) * a; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[c, -3.6e+70], t$95$1, If[LessEqual[c, 1.05e-116], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[c, 2e-35], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot t\right) \cdot j\\
\mathbf{if}\;c \leq -3.6 \cdot 10^{+70}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 1.05 \cdot 10^{-116}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;c \leq 2 \cdot 10^{-35}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -3.6e70 or 2.00000000000000002e-35 < c Initial program 67.1%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6440.9
Applied rewrites40.9%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.1
Applied rewrites52.1%
Taylor expanded in y around 0
Applied rewrites35.2%
if -3.6e70 < c < 1.05e-116Initial program 83.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6443.2
Applied rewrites43.2%
Taylor expanded in x around inf
Applied rewrites32.4%
Applied rewrites33.2%
if 1.05e-116 < c < 2.00000000000000002e-35Initial program 76.5%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.8
Applied rewrites51.8%
Taylor expanded in y around 0
Applied rewrites46.2%
Final simplification35.2%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* i b) a))) (if (<= i -3.5e+107) t_1 (if (<= i 7.8e+140) (* (* 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 = (i * b) * a;
double tmp;
if (i <= -3.5e+107) {
tmp = t_1;
} else if (i <= 7.8e+140) {
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 = (i * b) * a
if (i <= (-3.5d+107)) then
tmp = t_1
else if (i <= 7.8d+140) 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 = (i * b) * a;
double tmp;
if (i <= -3.5e+107) {
tmp = t_1;
} else if (i <= 7.8e+140) {
tmp = (y * x) * z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * b) * a tmp = 0 if i <= -3.5e+107: tmp = t_1 elif i <= 7.8e+140: tmp = (y * x) * z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * b) * a) tmp = 0.0 if (i <= -3.5e+107) tmp = t_1; elseif (i <= 7.8e+140) tmp = Float64(Float64(y * 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 = (i * b) * a; tmp = 0.0; if (i <= -3.5e+107) tmp = t_1; elseif (i <= 7.8e+140) 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[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[i, -3.5e+107], t$95$1, If[LessEqual[i, 7.8e+140], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot a\\
\mathbf{if}\;i \leq -3.5 \cdot 10^{+107}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 7.8 \cdot 10^{+140}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -3.4999999999999997e107 or 7.79999999999999949e140 < i Initial program 59.3%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6466.9
Applied rewrites66.9%
Taylor expanded in y around 0
Applied rewrites36.5%
if -3.4999999999999997e107 < i < 7.79999999999999949e140Initial program 80.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6446.3
Applied rewrites46.3%
Taylor expanded in x around inf
Applied rewrites26.5%
Final simplification29.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= x -4.3e-20) (* (* z x) y) (if (<= x 3.8e-54) (* (* i b) a) (* (* z y) x))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -4.3e-20) {
tmp = (z * x) * y;
} else if (x <= 3.8e-54) {
tmp = (i * b) * a;
} else {
tmp = (z * y) * x;
}
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 (x <= (-4.3d-20)) then
tmp = (z * x) * y
else if (x <= 3.8d-54) then
tmp = (i * b) * a
else
tmp = (z * y) * x
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 (x <= -4.3e-20) {
tmp = (z * x) * y;
} else if (x <= 3.8e-54) {
tmp = (i * b) * a;
} else {
tmp = (z * y) * x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -4.3e-20: tmp = (z * x) * y elif x <= 3.8e-54: tmp = (i * b) * a else: tmp = (z * y) * x return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -4.3e-20) tmp = Float64(Float64(z * x) * y); elseif (x <= 3.8e-54) tmp = Float64(Float64(i * b) * a); else tmp = Float64(Float64(z * y) * x); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -4.3e-20) tmp = (z * x) * y; elseif (x <= 3.8e-54) tmp = (i * b) * a; else tmp = (z * y) * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -4.3e-20], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[x, 3.8e-54], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -4.3 \cdot 10^{-20}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{-54}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\end{array}
\end{array}
if x < -4.30000000000000011e-20Initial program 73.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6453.6
Applied rewrites53.6%
Taylor expanded in x around inf
Applied rewrites36.8%
Applied rewrites39.7%
if -4.30000000000000011e-20 < x < 3.8000000000000002e-54Initial program 70.7%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6443.3
Applied rewrites43.3%
Taylor expanded in y around 0
Applied rewrites23.1%
if 3.8000000000000002e-54 < x Initial program 83.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6440.3
Applied rewrites40.3%
Taylor expanded in x around inf
Applied rewrites27.7%
Final simplification28.5%
(FPCore (x y z t a b c i j) :precision binary64 (* (* z x) y))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * x) * 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 = (z * x) * 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 (z * x) * y;
}
def code(x, y, z, t, a, b, c, i, j): return (z * x) * y
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(z * x) * y) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (z * x) * y; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision]
\begin{array}{l}
\\
\left(z \cdot x\right) \cdot y
\end{array}
Initial program 75.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6441.1
Applied rewrites41.1%
Taylor expanded in x around inf
Applied rewrites20.4%
Applied rewrites21.1%
(FPCore (x y z t a b c i j) :precision binary64 (* (* z y) x))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * y) * x;
}
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 = (z * y) * x
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 (z * y) * x;
}
def code(x, y, z, t, a, b, c, i, j): return (z * y) * x
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(z * y) * x) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (z * y) * x; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]
\begin{array}{l}
\\
\left(z \cdot y\right) \cdot x
\end{array}
Initial program 75.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6441.1
Applied rewrites41.1%
Taylor expanded in x around inf
Applied rewrites20.4%
Final simplification20.4%
(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 2024331
(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)))))