
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))
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) - (t * i)))) + (j * ((c * a) - (y * 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 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * 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 ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i))); 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[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 22 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))
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) - (t * i)))) + (j * ((c * a) - (y * 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 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * 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 ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i))); 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[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i))))
(* j (- (* c a) (* y i))))))
(if (<= t_1 INFINITY)
t_1
(*
(fma
(- j)
y
(+
(/ (fma (fma (- z) b (* j a)) c (* (fma (- a) t (* z y)) x)) i)
(* b t)))
i))))
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) - (t * i)))) + (j * ((c * a) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(-j, y, ((fma(fma(-z, b, (j * a)), c, (fma(-a, t, (z * y)) * x)) / i) + (b * t))) * i;
}
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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(fma(Float64(-j), y, Float64(Float64(fma(fma(Float64(-z), b, Float64(j * a)), c, Float64(fma(Float64(-a), t, Float64(z * y)) * x)) / i) + Float64(b * t))) * i); 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[(c * z), $MachinePrecision] - N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[((-j) * y + N[(N[(N[(N[((-z) * b + N[(j * a), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision] + N[(b * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]]]
\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 - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-j, y, \frac{\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot a\right), c, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)}{i} + b \cdot t\right) \cdot i\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) < +inf.0Initial program 90.2%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) Initial program 0.0%
Taylor expanded in i around inf
Applied rewrites49.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i))))
(* j (- (* c a) (* y i))))))
(if (<= t_1 INFINITY)
t_1
(fma (fma (- z) b (* j a)) c (* (fma (- a) t (* z y)) x)))))
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) - (t * i)))) + (j * ((c * a) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(fma(-z, b, (j * a)), c, (fma(-a, t, (z * y)) * x));
}
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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = fma(fma(Float64(-z), b, Float64(j * a)), c, Float64(fma(Float64(-a), t, Float64(z * y)) * x)); 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[(c * z), $MachinePrecision] - N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[((-z) * b + N[(j * a), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]
\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 - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot a\right), c, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) < +inf.0Initial program 90.2%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) Initial program 0.0%
Taylor expanded in i around 0
fp-cancel-sub-sign-invN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites49.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) x (* i b)) t)))
(if (<= t -3.8e+171)
t_1
(if (<= t 6e-304)
(fma (fma (- z) b (* j a)) c (* (fma (- a) t (* z y)) x))
(if (<= t 2.05e+85)
(fma (fma (- i) y (* c a)) j (* (fma (- b) c (* y x)) z))
(if (<= t 1.9e+204)
(fma (- b) (fma (- i) t (* c z)) (* (fma (- x) t (* j c)) 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 = fma(-a, x, (i * b)) * t;
double tmp;
if (t <= -3.8e+171) {
tmp = t_1;
} else if (t <= 6e-304) {
tmp = fma(fma(-z, b, (j * a)), c, (fma(-a, t, (z * y)) * x));
} else if (t <= 2.05e+85) {
tmp = fma(fma(-i, y, (c * a)), j, (fma(-b, c, (y * x)) * z));
} else if (t <= 1.9e+204) {
tmp = fma(-b, fma(-i, t, (c * z)), (fma(-x, t, (j * c)) * a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), x, Float64(i * b)) * t) tmp = 0.0 if (t <= -3.8e+171) tmp = t_1; elseif (t <= 6e-304) tmp = fma(fma(Float64(-z), b, Float64(j * a)), c, Float64(fma(Float64(-a), t, Float64(z * y)) * x)); elseif (t <= 2.05e+85) tmp = fma(fma(Float64(-i), y, Float64(c * a)), j, Float64(fma(Float64(-b), c, Float64(y * x)) * z)); elseif (t <= 1.9e+204) tmp = fma(Float64(-b), fma(Float64(-i), t, Float64(c * z)), Float64(fma(Float64(-x), t, Float64(j * c)) * a)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -3.8e+171], t$95$1, If[LessEqual[t, 6e-304], N[(N[((-z) * b + N[(j * a), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.05e+85], N[(N[((-i) * y + N[(c * a), $MachinePrecision]), $MachinePrecision] * j + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.9e+204], N[((-b) * N[((-i) * t + N[(c * z), $MachinePrecision]), $MachinePrecision] + N[(N[((-x) * t + N[(j * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
\mathbf{if}\;t \leq -3.8 \cdot 10^{+171}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-304}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot a\right), c, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;t \leq 2.05 \cdot 10^{+85}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-i, y, c \cdot a\right), j, \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\right)\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{+204}:\\
\;\;\;\;\mathsf{fma}\left(-b, \mathsf{fma}\left(-i, t, c \cdot z\right), \mathsf{fma}\left(-x, t, j \cdot c\right) \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.8000000000000002e171 or 1.8999999999999999e204 < t Initial program 59.8%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6475.0
Applied rewrites75.0%
if -3.8000000000000002e171 < t < 6.0000000000000002e-304Initial program 74.3%
Taylor expanded in i around 0
fp-cancel-sub-sign-invN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites76.5%
if 6.0000000000000002e-304 < t < 2.04999999999999989e85Initial program 81.8%
Taylor expanded in t around 0
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites80.5%
if 2.04999999999999989e85 < t < 1.8999999999999999e204Initial program 69.4%
Taylor expanded in y around 0
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6480.0
Applied rewrites80.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) x (* i b)) t)))
(if (<= t -3.8e+171)
t_1
(if (<= t 6e-304)
(fma (fma (- z) b (* j a)) c (* (fma (- a) t (* z y)) x))
(if (<= t 1.5e+87)
(fma (fma (- i) y (* c a)) j (* (fma (- b) c (* 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 = fma(-a, x, (i * b)) * t;
double tmp;
if (t <= -3.8e+171) {
tmp = t_1;
} else if (t <= 6e-304) {
tmp = fma(fma(-z, b, (j * a)), c, (fma(-a, t, (z * y)) * x));
} else if (t <= 1.5e+87) {
tmp = fma(fma(-i, y, (c * a)), j, (fma(-b, c, (y * x)) * z));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), x, Float64(i * b)) * t) tmp = 0.0 if (t <= -3.8e+171) tmp = t_1; elseif (t <= 6e-304) tmp = fma(fma(Float64(-z), b, Float64(j * a)), c, Float64(fma(Float64(-a), t, Float64(z * y)) * x)); elseif (t <= 1.5e+87) tmp = fma(fma(Float64(-i), y, Float64(c * a)), j, Float64(fma(Float64(-b), c, Float64(y * 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[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -3.8e+171], t$95$1, If[LessEqual[t, 6e-304], N[(N[((-z) * b + N[(j * a), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.5e+87], N[(N[((-i) * y + N[(c * a), $MachinePrecision]), $MachinePrecision] * j + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
\mathbf{if}\;t \leq -3.8 \cdot 10^{+171}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-304}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot a\right), c, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;t \leq 1.5 \cdot 10^{+87}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-i, y, c \cdot a\right), j, \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.8000000000000002e171 or 1.4999999999999999e87 < t Initial program 63.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.8
Applied rewrites70.8%
if -3.8000000000000002e171 < t < 6.0000000000000002e-304Initial program 74.3%
Taylor expanded in i around 0
fp-cancel-sub-sign-invN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-inN/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
*-commutativeN/A
Applied rewrites76.5%
if 6.0000000000000002e-304 < t < 1.4999999999999999e87Initial program 81.8%
Taylor expanded in t around 0
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites80.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma a c (* (- i) y)) j)) (t_2 (* (fma (- t) a (* y z)) x)))
(if (<= x -4.8e+64)
t_2
(if (<= x -5.8e-75)
(+ (* (* i b) t) (* (* j c) a))
(if (<= x -3.6e-191)
(* (fma j a (* (- z) b)) c)
(if (<= x 1.8e-267)
t_1
(if (<= x 425.0)
(* (fma (- z) c (* i t)) b)
(if (<= x 5.4e+89) 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(a, c, (-i * y)) * j;
double t_2 = fma(-t, a, (y * z)) * x;
double tmp;
if (x <= -4.8e+64) {
tmp = t_2;
} else if (x <= -5.8e-75) {
tmp = ((i * b) * t) + ((j * c) * a);
} else if (x <= -3.6e-191) {
tmp = fma(j, a, (-z * b)) * c;
} else if (x <= 1.8e-267) {
tmp = t_1;
} else if (x <= 425.0) {
tmp = fma(-z, c, (i * t)) * b;
} else if (x <= 5.4e+89) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(a, c, Float64(Float64(-i) * y)) * j) t_2 = Float64(fma(Float64(-t), a, Float64(y * z)) * x) tmp = 0.0 if (x <= -4.8e+64) tmp = t_2; elseif (x <= -5.8e-75) tmp = Float64(Float64(Float64(i * b) * t) + Float64(Float64(j * c) * a)); elseif (x <= -3.6e-191) tmp = Float64(fma(j, a, Float64(Float64(-z) * b)) * c); elseif (x <= 1.8e-267) tmp = t_1; elseif (x <= 425.0) tmp = Float64(fma(Float64(-z), c, Float64(i * t)) * b); elseif (x <= 5.4e+89) 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[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-t) * a + N[(y * z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.8e+64], t$95$2, If[LessEqual[x, -5.8e-75], N[(N[(N[(i * b), $MachinePrecision] * t), $MachinePrecision] + N[(N[(j * c), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.6e-191], N[(N[(j * a + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 1.8e-267], t$95$1, If[LessEqual[x, 425.0], N[(N[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 5.4e+89], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
t_2 := \mathsf{fma}\left(-t, a, y \cdot z\right) \cdot x\\
\mathbf{if}\;x \leq -4.8 \cdot 10^{+64}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -5.8 \cdot 10^{-75}:\\
\;\;\;\;\left(i \cdot b\right) \cdot t + \left(j \cdot c\right) \cdot a\\
\mathbf{elif}\;x \leq -3.6 \cdot 10^{-191}:\\
\;\;\;\;\mathsf{fma}\left(j, a, \left(-z\right) \cdot b\right) \cdot c\\
\mathbf{elif}\;x \leq 1.8 \cdot 10^{-267}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 425:\\
\;\;\;\;\mathsf{fma}\left(-z, c, i \cdot t\right) \cdot b\\
\mathbf{elif}\;x \leq 5.4 \cdot 10^{+89}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -4.79999999999999999e64 or 5.4e89 < x Initial program 71.8%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites80.4%
Taylor expanded in j around inf
Applied rewrites70.0%
Taylor expanded in x around inf
*-commutativeN/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
+-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6470.1
Applied rewrites70.1%
if -4.79999999999999999e64 < x < -5.8000000000000003e-75Initial program 68.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6468.9
Applied rewrites68.9%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6461.9
Applied rewrites61.9%
Taylor expanded in i around inf
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6472.4
Applied rewrites72.4%
if -5.8000000000000003e-75 < x < -3.60000000000000019e-191Initial program 65.6%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites62.8%
Taylor expanded in j around inf
Applied rewrites66.1%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6459.2
Applied rewrites59.2%
if -3.60000000000000019e-191 < x < 1.8000000000000001e-267 or 425 < x < 5.4e89Initial program 83.5%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites78.3%
Taylor expanded in j around inf
Applied rewrites79.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6471.8
Applied rewrites71.8%
if 1.8000000000000001e-267 < x < 425Initial program 71.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-neg-outN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6462.4
Applied rewrites62.4%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= t -7.4e+86) (not (<= t 1.5e+87))) (* (fma (- a) x (* i b)) t) (fma (fma (- i) y (* c a)) 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 ((t <= -7.4e+86) || !(t <= 1.5e+87)) {
tmp = fma(-a, x, (i * b)) * t;
} else {
tmp = fma(fma(-i, y, (c * a)), j, (fma(-b, c, (y * x)) * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((t <= -7.4e+86) || !(t <= 1.5e+87)) tmp = Float64(fma(Float64(-a), x, Float64(i * b)) * t); else tmp = fma(fma(Float64(-i), y, Float64(c * a)), j, Float64(fma(Float64(-b), c, Float64(y * x)) * z)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[t, -7.4e+86], N[Not[LessEqual[t, 1.5e+87]], $MachinePrecision]], N[(N[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], N[(N[((-i) * y + N[(c * a), $MachinePrecision]), $MachinePrecision] * j + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7.4 \cdot 10^{+86} \lor \neg \left(t \leq 1.5 \cdot 10^{+87}\right):\\
\;\;\;\;\mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-i, y, c \cdot a\right), j, \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\right)\\
\end{array}
\end{array}
if t < -7.39999999999999983e86 or 1.4999999999999999e87 < t Initial program 66.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6468.7
Applied rewrites68.7%
if -7.39999999999999983e86 < t < 1.4999999999999999e87Initial program 77.2%
Taylor expanded in t around 0
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites73.1%
Final simplification71.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma a c (* (- i) y)) j)) (t_2 (* (fma (- t) a (* y z)) x)))
(if (<= x -2.3e+74)
t_2
(if (<= x -3.6e-191)
(* (fma j a (* (- z) b)) c)
(if (<= x 1.8e-267)
t_1
(if (<= x 425.0)
(* (fma (- z) c (* i t)) b)
(if (<= x 5.4e+89) 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(a, c, (-i * y)) * j;
double t_2 = fma(-t, a, (y * z)) * x;
double tmp;
if (x <= -2.3e+74) {
tmp = t_2;
} else if (x <= -3.6e-191) {
tmp = fma(j, a, (-z * b)) * c;
} else if (x <= 1.8e-267) {
tmp = t_1;
} else if (x <= 425.0) {
tmp = fma(-z, c, (i * t)) * b;
} else if (x <= 5.4e+89) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(a, c, Float64(Float64(-i) * y)) * j) t_2 = Float64(fma(Float64(-t), a, Float64(y * z)) * x) tmp = 0.0 if (x <= -2.3e+74) tmp = t_2; elseif (x <= -3.6e-191) tmp = Float64(fma(j, a, Float64(Float64(-z) * b)) * c); elseif (x <= 1.8e-267) tmp = t_1; elseif (x <= 425.0) tmp = Float64(fma(Float64(-z), c, Float64(i * t)) * b); elseif (x <= 5.4e+89) 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[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-t) * a + N[(y * z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.3e+74], t$95$2, If[LessEqual[x, -3.6e-191], N[(N[(j * a + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 1.8e-267], t$95$1, If[LessEqual[x, 425.0], N[(N[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 5.4e+89], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
t_2 := \mathsf{fma}\left(-t, a, y \cdot z\right) \cdot x\\
\mathbf{if}\;x \leq -2.3 \cdot 10^{+74}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -3.6 \cdot 10^{-191}:\\
\;\;\;\;\mathsf{fma}\left(j, a, \left(-z\right) \cdot b\right) \cdot c\\
\mathbf{elif}\;x \leq 1.8 \cdot 10^{-267}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 425:\\
\;\;\;\;\mathsf{fma}\left(-z, c, i \cdot t\right) \cdot b\\
\mathbf{elif}\;x \leq 5.4 \cdot 10^{+89}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -2.2999999999999999e74 or 5.4e89 < x Initial program 73.3%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites82.1%
Taylor expanded in j around inf
Applied rewrites70.4%
Taylor expanded in x around inf
*-commutativeN/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
+-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6470.5
Applied rewrites70.5%
if -2.2999999999999999e74 < x < -3.60000000000000019e-191Initial program 65.1%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites62.3%
Taylor expanded in j around inf
Applied rewrites62.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6451.7
Applied rewrites51.7%
if -3.60000000000000019e-191 < x < 1.8000000000000001e-267 or 425 < x < 5.4e89Initial program 83.5%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites78.3%
Taylor expanded in j around inf
Applied rewrites79.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6471.8
Applied rewrites71.8%
if 1.8000000000000001e-267 < x < 425Initial program 71.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
distribute-lft-neg-outN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6462.4
Applied rewrites62.4%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= z -2.12e+92) (not (<= z 1.65e-5))) (fma (* c a) j (* (fma (- b) c (* y x)) z)) (+ (* (* i t) b) (* j (- (* c a) (* y i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -2.12e+92) || !(z <= 1.65e-5)) {
tmp = fma((c * a), j, (fma(-b, c, (y * x)) * z));
} else {
tmp = ((i * t) * b) + (j * ((c * a) - (y * i)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((z <= -2.12e+92) || !(z <= 1.65e-5)) tmp = fma(Float64(c * a), j, Float64(fma(Float64(-b), c, Float64(y * x)) * z)); else tmp = Float64(Float64(Float64(i * t) * b) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[z, -2.12e+92], N[Not[LessEqual[z, 1.65e-5]], $MachinePrecision]], N[(N[(c * a), $MachinePrecision] * j + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], N[(N[(N[(i * t), $MachinePrecision] * b), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.12 \cdot 10^{+92} \lor \neg \left(z \leq 1.65 \cdot 10^{-5}\right):\\
\;\;\;\;\mathsf{fma}\left(c \cdot a, j, \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot t\right) \cdot b + j \cdot \left(c \cdot a - y \cdot i\right)\\
\end{array}
\end{array}
if z < -2.11999999999999999e92 or 1.6500000000000001e-5 < z Initial program 65.5%
Taylor expanded in t around 0
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites67.9%
Taylor expanded in y around 0
Applied rewrites68.5%
if -2.11999999999999999e92 < z < 1.6500000000000001e-5Initial program 78.7%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6463.1
Applied rewrites63.1%
Final simplification65.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- t) a (* y z)) x)))
(if (<= x -2.3e+74)
t_1
(if (<= x 4.2e-79)
(* (fma (- z) b (* j a)) c)
(if (<= x 19000000000000.0)
(* (fma (- a) x (* i b)) t)
(if (<= x 5.4e+89) (* (fma a c (* (- i) y)) 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(-t, a, (y * z)) * x;
double tmp;
if (x <= -2.3e+74) {
tmp = t_1;
} else if (x <= 4.2e-79) {
tmp = fma(-z, b, (j * a)) * c;
} else if (x <= 19000000000000.0) {
tmp = fma(-a, x, (i * b)) * t;
} else if (x <= 5.4e+89) {
tmp = fma(a, c, (-i * y)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-t), a, Float64(y * z)) * x) tmp = 0.0 if (x <= -2.3e+74) tmp = t_1; elseif (x <= 4.2e-79) tmp = Float64(fma(Float64(-z), b, Float64(j * a)) * c); elseif (x <= 19000000000000.0) tmp = Float64(fma(Float64(-a), x, Float64(i * b)) * t); elseif (x <= 5.4e+89) tmp = Float64(fma(a, c, Float64(Float64(-i) * y)) * 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[((-t) * a + N[(y * z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.3e+74], t$95$1, If[LessEqual[x, 4.2e-79], N[(N[((-z) * b + N[(j * a), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 19000000000000.0], N[(N[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 5.4e+89], N[(N[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-t, a, y \cdot z\right) \cdot x\\
\mathbf{if}\;x \leq -2.3 \cdot 10^{+74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.2 \cdot 10^{-79}:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot a\right) \cdot c\\
\mathbf{elif}\;x \leq 19000000000000:\\
\;\;\;\;\mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
\mathbf{elif}\;x \leq 5.4 \cdot 10^{+89}:\\
\;\;\;\;\mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.2999999999999999e74 or 5.4e89 < x Initial program 73.3%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites82.1%
Taylor expanded in j around inf
Applied rewrites70.4%
Taylor expanded in x around inf
*-commutativeN/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
+-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6470.5
Applied rewrites70.5%
if -2.2999999999999999e74 < x < 4.1999999999999999e-79Initial program 71.4%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
distribute-lft-neg-inN/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
*-commutativeN/A
lower-*.f6454.9
Applied rewrites54.9%
if 4.1999999999999999e-79 < x < 1.9e13Initial program 65.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6458.0
Applied rewrites58.0%
if 1.9e13 < x < 5.4e89Initial program 88.8%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites94.7%
Taylor expanded in j around inf
Applied rewrites78.1%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6478.5
Applied rewrites78.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- t) a (* y z)) x)))
(if (<= x -2.3e+74)
t_1
(if (<= x 4.2e-79)
(* (fma j a (* (- z) b)) c)
(if (<= x 19000000000000.0)
(* (fma (- a) x (* i b)) t)
(if (<= x 5.4e+89) (* (fma a c (* (- i) y)) 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(-t, a, (y * z)) * x;
double tmp;
if (x <= -2.3e+74) {
tmp = t_1;
} else if (x <= 4.2e-79) {
tmp = fma(j, a, (-z * b)) * c;
} else if (x <= 19000000000000.0) {
tmp = fma(-a, x, (i * b)) * t;
} else if (x <= 5.4e+89) {
tmp = fma(a, c, (-i * y)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-t), a, Float64(y * z)) * x) tmp = 0.0 if (x <= -2.3e+74) tmp = t_1; elseif (x <= 4.2e-79) tmp = Float64(fma(j, a, Float64(Float64(-z) * b)) * c); elseif (x <= 19000000000000.0) tmp = Float64(fma(Float64(-a), x, Float64(i * b)) * t); elseif (x <= 5.4e+89) tmp = Float64(fma(a, c, Float64(Float64(-i) * y)) * 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[((-t) * a + N[(y * z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.3e+74], t$95$1, If[LessEqual[x, 4.2e-79], N[(N[(j * a + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 19000000000000.0], N[(N[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 5.4e+89], N[(N[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-t, a, y \cdot z\right) \cdot x\\
\mathbf{if}\;x \leq -2.3 \cdot 10^{+74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.2 \cdot 10^{-79}:\\
\;\;\;\;\mathsf{fma}\left(j, a, \left(-z\right) \cdot b\right) \cdot c\\
\mathbf{elif}\;x \leq 19000000000000:\\
\;\;\;\;\mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
\mathbf{elif}\;x \leq 5.4 \cdot 10^{+89}:\\
\;\;\;\;\mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.2999999999999999e74 or 5.4e89 < x Initial program 73.3%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites82.1%
Taylor expanded in j around inf
Applied rewrites70.4%
Taylor expanded in x around inf
*-commutativeN/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
+-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6470.5
Applied rewrites70.5%
if -2.2999999999999999e74 < x < 4.1999999999999999e-79Initial program 71.4%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites68.1%
Taylor expanded in j around inf
Applied rewrites67.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6454.1
Applied rewrites54.1%
if 4.1999999999999999e-79 < x < 1.9e13Initial program 65.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6458.0
Applied rewrites58.0%
if 1.9e13 < x < 5.4e89Initial program 88.8%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites94.7%
Taylor expanded in j around inf
Applied rewrites78.1%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6478.5
Applied rewrites78.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) x (* i b)) t)) (t_2 (* (fma a c (* (- i) y)) j)))
(if (<= j -4.4e+130)
t_2
(if (<= j -8e-154)
t_1
(if (<= j 2.95e-218)
(* (fma (- b) c (* y x)) z)
(if (<= j 3.5e+16) 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(-a, x, (i * b)) * t;
double t_2 = fma(a, c, (-i * y)) * j;
double tmp;
if (j <= -4.4e+130) {
tmp = t_2;
} else if (j <= -8e-154) {
tmp = t_1;
} else if (j <= 2.95e-218) {
tmp = fma(-b, c, (y * x)) * z;
} else if (j <= 3.5e+16) {
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(-a), x, Float64(i * b)) * t) t_2 = Float64(fma(a, c, Float64(Float64(-i) * y)) * j) tmp = 0.0 if (j <= -4.4e+130) tmp = t_2; elseif (j <= -8e-154) tmp = t_1; elseif (j <= 2.95e-218) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (j <= 3.5e+16) 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[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, Block[{t$95$2 = N[(N[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -4.4e+130], t$95$2, If[LessEqual[j, -8e-154], t$95$1, If[LessEqual[j, 2.95e-218], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[j, 3.5e+16], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
t_2 := \mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
\mathbf{if}\;j \leq -4.4 \cdot 10^{+130}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq -8 \cdot 10^{-154}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 2.95 \cdot 10^{-218}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;j \leq 3.5 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if j < -4.39999999999999987e130 or 3.5e16 < j Initial program 74.1%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites71.7%
Taylor expanded in j around inf
Applied rewrites83.0%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6470.2
Applied rewrites70.2%
if -4.39999999999999987e130 < j < -7.9999999999999998e-154 or 2.95000000000000003e-218 < j < 3.5e16Initial program 73.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.3
Applied rewrites56.3%
if -7.9999999999999998e-154 < j < 2.95000000000000003e-218Initial program 68.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
distribute-lft-neg-inN/A
mul-1-negN/A
+-commutativeN/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.2
Applied rewrites56.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma a c (* (- i) y)) j)))
(if (<= j -66000000000.0)
t_1
(if (<= j -1.5e-153)
(* (* i b) t)
(if (<= j -1.72e-196)
(* (* (- c) z) b)
(if (<= j 4.4e-8) (* (- a) (* t x)) 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(a, c, (-i * y)) * j;
double tmp;
if (j <= -66000000000.0) {
tmp = t_1;
} else if (j <= -1.5e-153) {
tmp = (i * b) * t;
} else if (j <= -1.72e-196) {
tmp = (-c * z) * b;
} else if (j <= 4.4e-8) {
tmp = -a * (t * x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(a, c, Float64(Float64(-i) * y)) * j) tmp = 0.0 if (j <= -66000000000.0) tmp = t_1; elseif (j <= -1.5e-153) tmp = Float64(Float64(i * b) * t); elseif (j <= -1.72e-196) tmp = Float64(Float64(Float64(-c) * z) * b); elseif (j <= 4.4e-8) tmp = Float64(Float64(-a) * Float64(t * x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -66000000000.0], t$95$1, If[LessEqual[j, -1.5e-153], N[(N[(i * b), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[j, -1.72e-196], N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[j, 4.4e-8], N[((-a) * N[(t * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
\mathbf{if}\;j \leq -66000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -1.5 \cdot 10^{-153}:\\
\;\;\;\;\left(i \cdot b\right) \cdot t\\
\mathbf{elif}\;j \leq -1.72 \cdot 10^{-196}:\\
\;\;\;\;\left(\left(-c\right) \cdot z\right) \cdot b\\
\mathbf{elif}\;j \leq 4.4 \cdot 10^{-8}:\\
\;\;\;\;\left(-a\right) \cdot \left(t \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -6.6e10 or 4.3999999999999997e-8 < j Initial program 72.6%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites73.2%
Taylor expanded in j around inf
Applied rewrites83.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6462.2
Applied rewrites62.2%
if -6.6e10 < j < -1.5e-153Initial program 68.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6459.9
Applied rewrites59.9%
Taylor expanded in x around 0
Applied rewrites45.6%
if -1.5e-153 < j < -1.72e-196Initial program 64.2%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites66.0%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6475.6
Applied rewrites75.6%
Taylor expanded in z around inf
Applied rewrites75.8%
if -1.72e-196 < j < 4.3999999999999997e-8Initial program 76.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6446.4
Applied rewrites46.4%
Taylor expanded in x around inf
Applied rewrites38.7%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= t -7.2e+85) (not (<= t 2.25e+83))) (* (fma (- a) x (* i b)) t) (fma (* c a) 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 ((t <= -7.2e+85) || !(t <= 2.25e+83)) {
tmp = fma(-a, x, (i * b)) * t;
} else {
tmp = fma((c * a), j, (fma(-b, c, (y * x)) * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((t <= -7.2e+85) || !(t <= 2.25e+83)) tmp = Float64(fma(Float64(-a), x, Float64(i * b)) * t); else tmp = fma(Float64(c * a), j, Float64(fma(Float64(-b), c, Float64(y * x)) * z)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[t, -7.2e+85], N[Not[LessEqual[t, 2.25e+83]], $MachinePrecision]], N[(N[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], N[(N[(c * a), $MachinePrecision] * j + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -7.2 \cdot 10^{+85} \lor \neg \left(t \leq 2.25 \cdot 10^{+83}\right):\\
\;\;\;\;\mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(c \cdot a, j, \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\right)\\
\end{array}
\end{array}
if t < -7.1999999999999996e85 or 2.25e83 < t Initial program 66.8%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6468.4
Applied rewrites68.4%
if -7.1999999999999996e85 < t < 2.25e83Initial program 77.0%
Taylor expanded in t around 0
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites72.8%
Taylor expanded in y around 0
Applied rewrites63.2%
Final simplification65.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* a c) j)))
(if (<= j -1.75e+16)
t_1
(if (<= j -1.5e-153)
(* (* i b) t)
(if (<= j -1.72e-196)
(* (* (- c) z) b)
(if (<= j 9.6e+16) (* (- a) (* t x)) 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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -1.5e-153) {
tmp = (i * b) * t;
} else if (j <= -1.72e-196) {
tmp = (-c * z) * b;
} else if (j <= 9.6e+16) {
tmp = -a * (t * x);
} 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 * c) * j
if (j <= (-1.75d+16)) then
tmp = t_1
else if (j <= (-1.5d-153)) then
tmp = (i * b) * t
else if (j <= (-1.72d-196)) then
tmp = (-c * z) * b
else if (j <= 9.6d+16) then
tmp = -a * (t * x)
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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -1.5e-153) {
tmp = (i * b) * t;
} else if (j <= -1.72e-196) {
tmp = (-c * z) * b;
} else if (j <= 9.6e+16) {
tmp = -a * (t * x);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (a * c) * j tmp = 0 if j <= -1.75e+16: tmp = t_1 elif j <= -1.5e-153: tmp = (i * b) * t elif j <= -1.72e-196: tmp = (-c * z) * b elif j <= 9.6e+16: tmp = -a * (t * x) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(a * c) * j) tmp = 0.0 if (j <= -1.75e+16) tmp = t_1; elseif (j <= -1.5e-153) tmp = Float64(Float64(i * b) * t); elseif (j <= -1.72e-196) tmp = Float64(Float64(Float64(-c) * z) * b); elseif (j <= 9.6e+16) tmp = Float64(Float64(-a) * Float64(t * x)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (a * c) * j; tmp = 0.0; if (j <= -1.75e+16) tmp = t_1; elseif (j <= -1.5e-153) tmp = (i * b) * t; elseif (j <= -1.72e-196) tmp = (-c * z) * b; elseif (j <= 9.6e+16) tmp = -a * (t * x); 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[(a * c), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -1.75e+16], t$95$1, If[LessEqual[j, -1.5e-153], N[(N[(i * b), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[j, -1.72e-196], N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[j, 9.6e+16], N[((-a) * N[(t * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot c\right) \cdot j\\
\mathbf{if}\;j \leq -1.75 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -1.5 \cdot 10^{-153}:\\
\;\;\;\;\left(i \cdot b\right) \cdot t\\
\mathbf{elif}\;j \leq -1.72 \cdot 10^{-196}:\\
\;\;\;\;\left(\left(-c\right) \cdot z\right) \cdot b\\
\mathbf{elif}\;j \leq 9.6 \cdot 10^{+16}:\\
\;\;\;\;\left(-a\right) \cdot \left(t \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.75e16 or 9.6e16 < j Initial program 71.8%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites72.4%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6454.5
Applied rewrites54.5%
Taylor expanded in z around 0
Applied rewrites41.6%
Applied rewrites44.7%
if -1.75e16 < j < -1.5e-153Initial program 68.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6459.9
Applied rewrites59.9%
Taylor expanded in x around 0
Applied rewrites45.6%
if -1.5e-153 < j < -1.72e-196Initial program 64.2%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites66.0%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6475.6
Applied rewrites75.6%
Taylor expanded in z around inf
Applied rewrites75.8%
if -1.72e-196 < j < 9.6e16Initial program 77.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.6
Applied rewrites47.6%
Taylor expanded in x around inf
Applied rewrites37.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) x (* i b)) t)))
(if (<= t -7.5e-18)
t_1
(if (<= t -4.2e-300)
(* (fma j a (* (- z) b)) c)
(if (<= t 2.05e+85) (* (fma a c (* (- i) y)) 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(-a, x, (i * b)) * t;
double tmp;
if (t <= -7.5e-18) {
tmp = t_1;
} else if (t <= -4.2e-300) {
tmp = fma(j, a, (-z * b)) * c;
} else if (t <= 2.05e+85) {
tmp = fma(a, c, (-i * y)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), x, Float64(i * b)) * t) tmp = 0.0 if (t <= -7.5e-18) tmp = t_1; elseif (t <= -4.2e-300) tmp = Float64(fma(j, a, Float64(Float64(-z) * b)) * c); elseif (t <= 2.05e+85) tmp = Float64(fma(a, c, Float64(Float64(-i) * y)) * 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[((-a) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -7.5e-18], t$95$1, If[LessEqual[t, -4.2e-300], N[(N[(j * a + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[t, 2.05e+85], N[(N[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, x, i \cdot b\right) \cdot t\\
\mathbf{if}\;t \leq -7.5 \cdot 10^{-18}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{-300}:\\
\;\;\;\;\mathsf{fma}\left(j, a, \left(-z\right) \cdot b\right) \cdot c\\
\mathbf{elif}\;t \leq 2.05 \cdot 10^{+85}:\\
\;\;\;\;\mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -7.50000000000000015e-18 or 2.04999999999999989e85 < t Initial program 68.6%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6462.3
Applied rewrites62.3%
if -7.50000000000000015e-18 < t < -4.20000000000000007e-300Initial program 68.5%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites74.9%
Taylor expanded in j around inf
Applied rewrites78.6%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6463.0
Applied rewrites63.0%
if -4.20000000000000007e-300 < t < 2.04999999999999989e85Initial program 82.5%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites79.3%
Taylor expanded in j around inf
Applied rewrites68.2%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6452.3
Applied rewrites52.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (- a) (* t x))))
(if (<= x -2.25e+135)
t_1
(if (<= x 1.15e-89)
(* (fma j a (* (- z) b)) c)
(if (<= x 1.2e+121) (* (fma a c (* (- i) y)) 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 = -a * (t * x);
double tmp;
if (x <= -2.25e+135) {
tmp = t_1;
} else if (x <= 1.15e-89) {
tmp = fma(j, a, (-z * b)) * c;
} else if (x <= 1.2e+121) {
tmp = fma(a, c, (-i * y)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(-a) * Float64(t * x)) tmp = 0.0 if (x <= -2.25e+135) tmp = t_1; elseif (x <= 1.15e-89) tmp = Float64(fma(j, a, Float64(Float64(-z) * b)) * c); elseif (x <= 1.2e+121) tmp = Float64(fma(a, c, Float64(Float64(-i) * y)) * j); 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), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.25e+135], t$95$1, If[LessEqual[x, 1.15e-89], N[(N[(j * a + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 1.2e+121], N[(N[(a * c + N[((-i) * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot \left(t \cdot x\right)\\
\mathbf{if}\;x \leq -2.25 \cdot 10^{+135}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.15 \cdot 10^{-89}:\\
\;\;\;\;\mathsf{fma}\left(j, a, \left(-z\right) \cdot b\right) \cdot c\\
\mathbf{elif}\;x \leq 1.2 \cdot 10^{+121}:\\
\;\;\;\;\mathsf{fma}\left(a, c, \left(-i\right) \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.25000000000000004e135 or 1.2e121 < x Initial program 73.5%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.5
Applied rewrites54.5%
Taylor expanded in x around inf
Applied rewrites50.2%
if -2.25000000000000004e135 < x < 1.15e-89Initial program 71.7%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites68.6%
Taylor expanded in j around inf
Applied rewrites66.4%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6452.5
Applied rewrites52.5%
if 1.15e-89 < x < 1.2e121Initial program 75.8%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites81.3%
Taylor expanded in j around inf
Applied rewrites64.3%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f6455.2
Applied rewrites55.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* a c) j)))
(if (<= j -1.75e+16)
t_1
(if (<= j -3.2e-121)
(* (* i b) t)
(if (<= j 9.6e+16) (* (- a) (* t x)) 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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -3.2e-121) {
tmp = (i * b) * t;
} else if (j <= 9.6e+16) {
tmp = -a * (t * x);
} 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 * c) * j
if (j <= (-1.75d+16)) then
tmp = t_1
else if (j <= (-3.2d-121)) then
tmp = (i * b) * t
else if (j <= 9.6d+16) then
tmp = -a * (t * x)
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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -3.2e-121) {
tmp = (i * b) * t;
} else if (j <= 9.6e+16) {
tmp = -a * (t * x);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (a * c) * j tmp = 0 if j <= -1.75e+16: tmp = t_1 elif j <= -3.2e-121: tmp = (i * b) * t elif j <= 9.6e+16: tmp = -a * (t * x) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(a * c) * j) tmp = 0.0 if (j <= -1.75e+16) tmp = t_1; elseif (j <= -3.2e-121) tmp = Float64(Float64(i * b) * t); elseif (j <= 9.6e+16) tmp = Float64(Float64(-a) * Float64(t * x)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (a * c) * j; tmp = 0.0; if (j <= -1.75e+16) tmp = t_1; elseif (j <= -3.2e-121) tmp = (i * b) * t; elseif (j <= 9.6e+16) tmp = -a * (t * x); 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[(a * c), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -1.75e+16], t$95$1, If[LessEqual[j, -3.2e-121], N[(N[(i * b), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[j, 9.6e+16], N[((-a) * N[(t * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot c\right) \cdot j\\
\mathbf{if}\;j \leq -1.75 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -3.2 \cdot 10^{-121}:\\
\;\;\;\;\left(i \cdot b\right) \cdot t\\
\mathbf{elif}\;j \leq 9.6 \cdot 10^{+16}:\\
\;\;\;\;\left(-a\right) \cdot \left(t \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.75e16 or 9.6e16 < j Initial program 71.8%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites72.4%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6454.5
Applied rewrites54.5%
Taylor expanded in z around 0
Applied rewrites41.6%
Applied rewrites44.7%
if -1.75e16 < j < -3.20000000000000019e-121Initial program 61.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.9
Applied rewrites54.9%
Taylor expanded in x around 0
Applied rewrites48.0%
if -3.20000000000000019e-121 < j < 9.6e16Initial program 77.5%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.2
Applied rewrites47.2%
Taylor expanded in x around inf
Applied rewrites34.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* a c) j)))
(if (<= j -1.75e+16)
t_1
(if (<= j -7.2e-121)
(* (* i b) t)
(if (<= j 9.6e+16) (* (* (- t) a) x) 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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -7.2e-121) {
tmp = (i * b) * t;
} else if (j <= 9.6e+16) {
tmp = (-t * a) * x;
} 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 * c) * j
if (j <= (-1.75d+16)) then
tmp = t_1
else if (j <= (-7.2d-121)) then
tmp = (i * b) * t
else if (j <= 9.6d+16) then
tmp = (-t * a) * x
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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -7.2e-121) {
tmp = (i * b) * t;
} else if (j <= 9.6e+16) {
tmp = (-t * a) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (a * c) * j tmp = 0 if j <= -1.75e+16: tmp = t_1 elif j <= -7.2e-121: tmp = (i * b) * t elif j <= 9.6e+16: tmp = (-t * a) * x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(a * c) * j) tmp = 0.0 if (j <= -1.75e+16) tmp = t_1; elseif (j <= -7.2e-121) tmp = Float64(Float64(i * b) * t); elseif (j <= 9.6e+16) tmp = Float64(Float64(Float64(-t) * a) * x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (a * c) * j; tmp = 0.0; if (j <= -1.75e+16) tmp = t_1; elseif (j <= -7.2e-121) tmp = (i * b) * t; elseif (j <= 9.6e+16) tmp = (-t * a) * x; 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[(a * c), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -1.75e+16], t$95$1, If[LessEqual[j, -7.2e-121], N[(N[(i * b), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[j, 9.6e+16], N[(N[((-t) * a), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot c\right) \cdot j\\
\mathbf{if}\;j \leq -1.75 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -7.2 \cdot 10^{-121}:\\
\;\;\;\;\left(i \cdot b\right) \cdot t\\
\mathbf{elif}\;j \leq 9.6 \cdot 10^{+16}:\\
\;\;\;\;\left(\left(-t\right) \cdot a\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.75e16 or 9.6e16 < j Initial program 71.8%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites72.4%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6454.5
Applied rewrites54.5%
Taylor expanded in z around 0
Applied rewrites41.6%
Applied rewrites44.7%
if -1.75e16 < j < -7.19999999999999967e-121Initial program 61.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.9
Applied rewrites54.9%
Taylor expanded in x around 0
Applied rewrites48.0%
if -7.19999999999999967e-121 < j < 9.6e16Initial program 77.5%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.2
Applied rewrites47.2%
Taylor expanded in x around inf
Applied rewrites45.0%
Taylor expanded in x around inf
Applied rewrites33.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* a c) j)))
(if (<= j -1.75e+16)
t_1
(if (<= j -7.6e-122)
(* (* i b) t)
(if (<= j 1.56e-16) (* (* z y) x) 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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -7.6e-122) {
tmp = (i * b) * t;
} else if (j <= 1.56e-16) {
tmp = (z * y) * x;
} 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 * c) * j
if (j <= (-1.75d+16)) then
tmp = t_1
else if (j <= (-7.6d-122)) then
tmp = (i * b) * t
else if (j <= 1.56d-16) then
tmp = (z * y) * x
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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -7.6e-122) {
tmp = (i * b) * t;
} else if (j <= 1.56e-16) {
tmp = (z * y) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (a * c) * j tmp = 0 if j <= -1.75e+16: tmp = t_1 elif j <= -7.6e-122: tmp = (i * b) * t elif j <= 1.56e-16: tmp = (z * y) * x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(a * c) * j) tmp = 0.0 if (j <= -1.75e+16) tmp = t_1; elseif (j <= -7.6e-122) tmp = Float64(Float64(i * b) * t); elseif (j <= 1.56e-16) tmp = Float64(Float64(z * y) * x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (a * c) * j; tmp = 0.0; if (j <= -1.75e+16) tmp = t_1; elseif (j <= -7.6e-122) tmp = (i * b) * t; elseif (j <= 1.56e-16) tmp = (z * y) * x; 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[(a * c), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -1.75e+16], t$95$1, If[LessEqual[j, -7.6e-122], N[(N[(i * b), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[j, 1.56e-16], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot c\right) \cdot j\\
\mathbf{if}\;j \leq -1.75 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -7.6 \cdot 10^{-122}:\\
\;\;\;\;\left(i \cdot b\right) \cdot t\\
\mathbf{elif}\;j \leq 1.56 \cdot 10^{-16}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.75e16 or 1.55999999999999996e-16 < j Initial program 72.9%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites73.4%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6452.5
Applied rewrites52.5%
Taylor expanded in z around 0
Applied rewrites40.2%
Applied rewrites43.1%
if -1.75e16 < j < -7.6000000000000002e-122Initial program 61.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.9
Applied rewrites54.9%
Taylor expanded in x around 0
Applied rewrites48.0%
if -7.6000000000000002e-122 < j < 1.55999999999999996e-16Initial program 76.3%
Taylor expanded in t around 0
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.4%
Taylor expanded in x around inf
Applied rewrites27.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* a c) j)))
(if (<= j -1.75e+16)
t_1
(if (<= j -7.6e-122)
(* (* i t) b)
(if (<= j 1.56e-16) (* (* z y) x) 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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -7.6e-122) {
tmp = (i * t) * b;
} else if (j <= 1.56e-16) {
tmp = (z * y) * x;
} 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 * c) * j
if (j <= (-1.75d+16)) then
tmp = t_1
else if (j <= (-7.6d-122)) then
tmp = (i * t) * b
else if (j <= 1.56d-16) then
tmp = (z * y) * x
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 * c) * j;
double tmp;
if (j <= -1.75e+16) {
tmp = t_1;
} else if (j <= -7.6e-122) {
tmp = (i * t) * b;
} else if (j <= 1.56e-16) {
tmp = (z * y) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (a * c) * j tmp = 0 if j <= -1.75e+16: tmp = t_1 elif j <= -7.6e-122: tmp = (i * t) * b elif j <= 1.56e-16: tmp = (z * y) * x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(a * c) * j) tmp = 0.0 if (j <= -1.75e+16) tmp = t_1; elseif (j <= -7.6e-122) tmp = Float64(Float64(i * t) * b); elseif (j <= 1.56e-16) tmp = Float64(Float64(z * y) * x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (a * c) * j; tmp = 0.0; if (j <= -1.75e+16) tmp = t_1; elseif (j <= -7.6e-122) tmp = (i * t) * b; elseif (j <= 1.56e-16) tmp = (z * y) * x; 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[(a * c), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -1.75e+16], t$95$1, If[LessEqual[j, -7.6e-122], N[(N[(i * t), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[j, 1.56e-16], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot c\right) \cdot j\\
\mathbf{if}\;j \leq -1.75 \cdot 10^{+16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -7.6 \cdot 10^{-122}:\\
\;\;\;\;\left(i \cdot t\right) \cdot b\\
\mathbf{elif}\;j \leq 1.56 \cdot 10^{-16}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.75e16 or 1.55999999999999996e-16 < j Initial program 72.9%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites73.4%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6452.5
Applied rewrites52.5%
Taylor expanded in z around 0
Applied rewrites40.2%
Applied rewrites43.1%
if -1.75e16 < j < -7.6000000000000002e-122Initial program 61.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.9
Applied rewrites54.9%
Taylor expanded in x around 0
Applied rewrites44.6%
if -7.6000000000000002e-122 < j < 1.55999999999999996e-16Initial program 76.3%
Taylor expanded in t around 0
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.4%
Taylor expanded in x around inf
Applied rewrites27.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= j -1.75e+16) (not (<= j 165000000000.0))) (* (* a c) j) (* (* i t) b)))
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.75e+16) || !(j <= 165000000000.0)) {
tmp = (a * c) * j;
} else {
tmp = (i * t) * b;
}
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 <= (-1.75d+16)) .or. (.not. (j <= 165000000000.0d0))) then
tmp = (a * c) * j
else
tmp = (i * t) * b
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 <= -1.75e+16) || !(j <= 165000000000.0)) {
tmp = (a * c) * j;
} else {
tmp = (i * t) * b;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (j <= -1.75e+16) or not (j <= 165000000000.0): tmp = (a * c) * j else: tmp = (i * t) * b return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((j <= -1.75e+16) || !(j <= 165000000000.0)) tmp = Float64(Float64(a * c) * j); else tmp = Float64(Float64(i * t) * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((j <= -1.75e+16) || ~((j <= 165000000000.0))) tmp = (a * c) * j; else tmp = (i * t) * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[j, -1.75e+16], N[Not[LessEqual[j, 165000000000.0]], $MachinePrecision]], N[(N[(a * c), $MachinePrecision] * j), $MachinePrecision], N[(N[(i * t), $MachinePrecision] * b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -1.75 \cdot 10^{+16} \lor \neg \left(j \leq 165000000000\right):\\
\;\;\;\;\left(a \cdot c\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot t\right) \cdot b\\
\end{array}
\end{array}
if j < -1.75e16 or 1.65e11 < j Initial program 72.0%
Taylor expanded in b around inf
*-commutativeN/A
associate--l+N/A
+-commutativeN/A
associate--r-N/A
lower-*.f64N/A
Applied rewrites72.6%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
fp-cancel-sign-sub-invN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6454.1
Applied rewrites54.1%
Taylor expanded in z around 0
Applied rewrites41.3%
Applied rewrites44.4%
if -1.75e16 < j < 1.65e11Initial program 73.8%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.5
Applied rewrites48.5%
Taylor expanded in x around 0
Applied rewrites25.2%
Final simplification34.6%
(FPCore (x y z t a b c i j) :precision binary64 (* (* i t) b))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (i * t) * b;
}
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 = (i * t) * b
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 (i * t) * b;
}
def code(x, y, z, t, a, b, c, i, j): return (i * t) * b
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(i * t) * b) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (i * t) * b; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(i * t), $MachinePrecision] * b), $MachinePrecision]
\begin{array}{l}
\\
\left(i \cdot t\right) \cdot b
\end{array}
Initial program 72.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
metadata-evalN/A
*-lft-identityN/A
associate-*r*N/A
mul-1-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6439.4
Applied rewrites39.4%
Taylor expanded in x around 0
Applied rewrites19.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* c a) (* y i))))
(t_2
(+
(-
(* x (- (* y z) (* t a)))
(/
(* b (- (pow (* c z) 2.0) (pow (* t i) 2.0)))
(+ (* c z) (* t i))))
t_1)))
(if (< x -1.469694296777705e-64)
t_2
(if (< x 3.2113527362226803e-147)
(- (* (- (* b i) (* x a)) t) (- (* z (* c b)) 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 = j * ((c * a) - (y * i));
double t_2 = ((x * ((y * z) - (t * a))) - ((b * (pow((c * z), 2.0) - pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
double tmp;
if (x < -1.469694296777705e-64) {
tmp = t_2;
} else if (x < 3.2113527362226803e-147) {
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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 = j * ((c * a) - (y * i))
t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ** 2.0d0) - ((t * i) ** 2.0d0))) / ((c * z) + (t * i)))) + t_1
if (x < (-1.469694296777705d-64)) then
tmp = t_2
else if (x < 3.2113527362226803d-147) then
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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 = j * ((c * a) - (y * i));
double t_2 = ((x * ((y * z) - (t * a))) - ((b * (Math.pow((c * z), 2.0) - Math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
double tmp;
if (x < -1.469694296777705e-64) {
tmp = t_2;
} else if (x < 3.2113527362226803e-147) {
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((c * a) - (y * i)) t_2 = ((x * ((y * z) - (t * a))) - ((b * (math.pow((c * z), 2.0) - math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1 tmp = 0 if x < -1.469694296777705e-64: tmp = t_2 elif x < 3.2113527362226803e-147: tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(c * a) - Float64(y * i))) t_2 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(Float64(b * Float64((Float64(c * z) ^ 2.0) - (Float64(t * i) ^ 2.0))) / Float64(Float64(c * z) + Float64(t * i)))) + t_1) tmp = 0.0 if (x < -1.469694296777705e-64) tmp = t_2; elseif (x < 3.2113527362226803e-147) tmp = Float64(Float64(Float64(Float64(b * i) - Float64(x * a)) * t) - Float64(Float64(z * Float64(c * b)) - 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 = j * ((c * a) - (y * i)); t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ^ 2.0) - ((t * i) ^ 2.0))) / ((c * z) + (t * i)))) + t_1; tmp = 0.0; if (x < -1.469694296777705e-64) tmp = t_2; elseif (x < 3.2113527362226803e-147) tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[Power[N[(c * z), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(t * i), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * z), $MachinePrecision] + N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[Less[x, -1.469694296777705e-64], t$95$2, If[Less[x, 3.2113527362226803e-147], N[(N[(N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] - N[(N[(z * N[(c * b), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(c \cdot a - y \cdot i\right)\\
t_2 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - \frac{b \cdot \left({\left(c \cdot z\right)}^{2} - {\left(t \cdot i\right)}^{2}\right)}{c \cdot z + t \cdot i}\right) + t\_1\\
\mathbf{if}\;x < -1.469694296777705 \cdot 10^{-64}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x < 3.2113527362226803 \cdot 10^{-147}:\\
\;\;\;\;\left(b \cdot i - x \cdot a\right) \cdot t - \left(z \cdot \left(c \cdot b\right) - t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024320
(FPCore (x y z t a b c i j)
:name "Data.Colour.Matrix:determinant from colour-2.3.3, A"
:precision binary64
:alt
(! :herbie-platform default (if (< x -293938859355541/2000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2) (pow (* t i) 2))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i)))) (if (< x 32113527362226803/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (* (- (* b i) (* x a)) t) (- (* z (* c b)) (* j (- (* c a) (* y i))))) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2) (pow (* t i) 2))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i)))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))