
(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 20 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 1e+292)
t_1
(if (<= t_1 INFINITY)
(*
(-
(fma
c
j
(/ (fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b)) t))
(* a x))
t)
(fma (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 t_1 = (((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b));
double tmp;
if (t_1 <= 1e+292) {
tmp = t_1;
} else if (t_1 <= ((double) INFINITY)) {
tmp = (fma(c, j, (fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b)) / t)) - (a * x)) * t;
} else {
tmp = fma(fma(-b, c, (y * x)), z, ((j * t) * c));
}
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 <= 1e+292) tmp = t_1; elseif (t_1 <= Inf) tmp = Float64(Float64(fma(c, j, Float64(fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b)) / t)) - Float64(a * x)) * t); else tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(Float64(j * t) * c)); 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, 1e+292], t$95$1, If[LessEqual[t$95$1, Infinity], N[(N[(N[(c * j + N[(N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] - N[(a * x), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision]), $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 10^{+292}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\left(\mathsf{fma}\left(c, j, \frac{\mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)}{t}\right) - a \cdot x\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \left(j \cdot t\right) \cdot c\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < 1e292Initial program 92.3%
if 1e292 < (+.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 80.9%
Taylor expanded in t around -inf
Applied rewrites91.1%
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%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f640.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f643.9
Applied rewrites3.9%
Taylor expanded in a around 0
associate--l+N/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
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.9%
Taylor expanded in c around inf
Applied rewrites66.8%
Final simplification86.9%
(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 2e+285)
t_1
(if (<= t_1 INFINITY)
(fma
(fma (- x) a (* j c))
t
(fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b)))
(fma (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 t_1 = (((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b));
double tmp;
if (t_1 <= 2e+285) {
tmp = t_1;
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma(fma(-x, a, (j * c)), t, fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b)));
} else {
tmp = fma(fma(-b, c, (y * x)), z, ((j * t) * c));
}
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 <= 2e+285) tmp = t_1; elseif (t_1 <= Inf) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b))); else tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(Float64(j * t) * c)); 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, 2e+285], t$95$1, If[LessEqual[t$95$1, Infinity], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision]), $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 2 \cdot 10^{+285}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \left(j \cdot t\right) \cdot c\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < 2e285Initial program 92.3%
if 2e285 < (+.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.2%
Taylor expanded in t around 0
Applied rewrites89.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%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f640.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f643.9
Applied rewrites3.9%
Taylor expanded in a around 0
associate--l+N/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
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.9%
Taylor expanded in c around inf
Applied rewrites66.8%
Final simplification86.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (- b) c (* y x)))
(t_2
(-
(* (- (* c t) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b)))))
(if (<= t_2 1e-229)
(fma (fma (- x) t (* i b)) a (fma t_1 z (* (fma (- i) y (* c t)) j)))
(if (<= t_2 INFINITY)
(fma
(fma (- x) a (* j c))
t
(fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b)))
(fma t_1 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 t_1 = fma(-b, c, (y * x));
double t_2 = (((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b));
double tmp;
if (t_2 <= 1e-229) {
tmp = fma(fma(-x, t, (i * b)), a, fma(t_1, z, (fma(-i, y, (c * t)) * j)));
} else if (t_2 <= ((double) INFINITY)) {
tmp = fma(fma(-x, a, (j * c)), t, fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b)));
} else {
tmp = fma(t_1, z, ((j * t) * c));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(-b), c, Float64(y * x)) t_2 = 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_2 <= 1e-229) tmp = fma(fma(Float64(-x), t, Float64(i * b)), a, fma(t_1, z, Float64(fma(Float64(-i), y, Float64(c * t)) * j))); elseif (t_2 <= Inf) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b))); else tmp = fma(t_1, z, Float64(Float64(j * t) * c)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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$2, 1e-229], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a + N[(t$95$1 * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * z + N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, c, y \cdot x\right)\\
t_2 := \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\_2 \leq 10^{-229}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, t, i \cdot b\right), a, \mathsf{fma}\left(t\_1, z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\right)\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t\_1, z, \left(j \cdot t\right) \cdot c\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < 1.00000000000000007e-229Initial program 90.6%
Taylor expanded in a around 0
associate--l+N/A
*-commutativeN/A
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
lower-fma.f64N/A
Applied rewrites88.6%
if 1.00000000000000007e-229 < (+.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 86.7%
Taylor expanded in t around 0
Applied rewrites88.5%
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%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f640.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f643.9
Applied rewrites3.9%
Taylor expanded in a around 0
associate--l+N/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
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.9%
Taylor expanded in c around inf
Applied rewrites66.8%
Final simplification84.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z 5.8e+45)
(fma
(fma (- x) a (* j c))
t
(fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b)))
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= 5.8e+45) {
tmp = fma(fma(-x, a, (j * c)), t, fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b)));
} else {
tmp = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= 5.8e+45) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b))); else tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, 5.8e+45], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 5.8 \cdot 10^{+45}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\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)\\
\end{array}
\end{array}
if z < 5.7999999999999994e45Initial program 73.3%
Taylor expanded in t around 0
Applied rewrites80.0%
if 5.7999999999999994e45 < z Initial program 61.3%
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
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites89.8%
Final simplification81.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- y) j (* b a)) i (* (fma (- c) b (* y x)) z))))
(if (<= i -1.8e+102)
t_1
(if (<= i 8.5e+74)
(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(fma(-y, j, (b * a)), i, (fma(-c, b, (y * x)) * z));
double tmp;
if (i <= -1.8e+102) {
tmp = t_1;
} else if (i <= 8.5e+74) {
tmp = 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 = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(fma(Float64(-c), b, Float64(y * x)) * z)) tmp = 0.0 if (i <= -1.8e+102) tmp = t_1; elseif (i <= 8.5e+74) tmp = 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[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.8e+102], t$95$1, If[LessEqual[i, 8.5e+74], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\right)\\
\mathbf{if}\;i \leq -1.8 \cdot 10^{+102}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 8.5 \cdot 10^{+74}:\\
\;\;\;\;\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}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.8000000000000001e102 or 8.50000000000000028e74 < i Initial program 69.8%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites68.6%
Taylor expanded in z around 0
Applied rewrites79.8%
if -1.8000000000000001e102 < i < 8.50000000000000028e74Initial program 71.7%
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
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites72.2%
Final simplification75.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) a (* j c)) t)))
(if (<= t -5e+190)
t_1
(if (<= t 2.9e+19)
(fma (fma (- y) j (* b a)) i (* (fma (- c) b (* 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(-x, a, (j * c)) * t;
double tmp;
if (t <= -5e+190) {
tmp = t_1;
} else if (t <= 2.9e+19) {
tmp = fma(fma(-y, j, (b * a)), i, (fma(-c, b, (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(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -5e+190) tmp = t_1; elseif (t <= 2.9e+19) tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(fma(Float64(-c), b, 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[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -5e+190], t$95$1, If[LessEqual[t, 2.9e+19], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $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 -5 \cdot 10^{+190}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2.9 \cdot 10^{+19}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -5.00000000000000036e190 or 2.9e19 < t Initial program 57.1%
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
lower-*.f6472.9
Applied rewrites72.9%
if -5.00000000000000036e190 < t < 2.9e19Initial program 77.7%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites69.9%
Taylor expanded in z around 0
Applied rewrites73.2%
Final simplification73.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- b) c (* y x)) z (* (* j t) c))))
(if (<= z -1.75e-44)
t_1
(if (<= z 400000000.0) (+ (* (* i b) a) (* (- (* c t) (* 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(fma(-b, c, (y * x)), z, ((j * t) * c));
double tmp;
if (z <= -1.75e-44) {
tmp = t_1;
} else if (z <= 400000000.0) {
tmp = ((i * b) * a) + (((c * t) - (i * y)) * j);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(Float64(j * t) * c)) tmp = 0.0 if (z <= -1.75e-44) tmp = t_1; elseif (z <= 400000000.0) tmp = Float64(Float64(Float64(i * b) * a) + Float64(Float64(Float64(c * t) - 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[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.75e-44], t$95$1, If[LessEqual[z, 400000000.0], N[(N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \left(j \cdot t\right) \cdot c\right)\\
\mathbf{if}\;z \leq -1.75 \cdot 10^{-44}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 400000000:\\
\;\;\;\;\left(i \cdot b\right) \cdot a + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.7499999999999999e-44 or 4e8 < z Initial program 64.8%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6464.8
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6465.5
Applied rewrites65.5%
Taylor expanded in a around 0
associate--l+N/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
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites77.2%
Taylor expanded in c around inf
Applied rewrites73.5%
if -1.7499999999999999e-44 < z < 4e8Initial program 77.7%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6467.4
Applied rewrites67.4%
Final simplification70.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)))
(if (<= z -6e+151)
t_1
(if (<= z -1.5e+71)
(* (fma (- b) z (* j t)) c)
(if (<= z -1.8e-167)
(* (fma b a (* (- y) j)) i)
(if (<= z 128000000.0) (* (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(-b, c, (y * x)) * z;
double tmp;
if (z <= -6e+151) {
tmp = t_1;
} else if (z <= -1.5e+71) {
tmp = fma(-b, z, (j * t)) * c;
} else if (z <= -1.8e-167) {
tmp = fma(b, a, (-y * j)) * i;
} else if (z <= 128000000.0) {
tmp = 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(-b), c, Float64(y * x)) * z) tmp = 0.0 if (z <= -6e+151) tmp = t_1; elseif (z <= -1.5e+71) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); elseif (z <= -1.8e-167) tmp = Float64(fma(b, a, Float64(Float64(-y) * j)) * i); elseif (z <= 128000000.0) tmp = 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[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -6e+151], t$95$1, If[LessEqual[z, -1.5e+71], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[z, -1.8e-167], N[(N[(b * a + N[((-y) * j), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[z, 128000000.0], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $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 -6 \cdot 10^{+151}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.5 \cdot 10^{+71}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{elif}\;z \leq -1.8 \cdot 10^{-167}:\\
\;\;\;\;\mathsf{fma}\left(b, a, \left(-y\right) \cdot j\right) \cdot i\\
\mathbf{elif}\;z \leq 128000000:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.9999999999999998e151 or 1.28e8 < z Initial program 64.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
lower-*.f6474.1
Applied rewrites74.1%
if -5.9999999999999998e151 < z < -1.50000000000000006e71Initial program 70.2%
Taylor expanded in c 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-*.f6470.4
Applied rewrites70.4%
if -1.50000000000000006e71 < z < -1.8e-167Initial program 72.9%
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-*.f6457.2
Applied rewrites57.2%
Applied rewrites57.2%
if -1.8e-167 < z < 1.28e8Initial program 76.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6454.2
Applied rewrites54.2%
Final simplification63.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) y (* c t)) j)))
(if (<= j -2.5e-19)
t_1
(if (<= j 5.9e+134) (fma (* b a) i (* (fma (- c) b (* 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(-i, y, (c * t)) * j;
double tmp;
if (j <= -2.5e-19) {
tmp = t_1;
} else if (j <= 5.9e+134) {
tmp = fma((b * a), i, (fma(-c, b, (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(-i), y, Float64(c * t)) * j) tmp = 0.0 if (j <= -2.5e-19) tmp = t_1; elseif (j <= 5.9e+134) tmp = fma(Float64(b * a), i, Float64(fma(Float64(-c), b, 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[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -2.5e-19], t$95$1, If[LessEqual[j, 5.9e+134], N[(N[(b * a), $MachinePrecision] * i + N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{if}\;j \leq -2.5 \cdot 10^{-19}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 5.9 \cdot 10^{+134}:\\
\;\;\;\;\mathsf{fma}\left(b \cdot a, i, \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -2.5000000000000002e-19 or 5.90000000000000008e134 < j Initial program 68.9%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6472.5
Applied rewrites72.5%
if -2.5000000000000002e-19 < j < 5.90000000000000008e134Initial program 72.6%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites67.2%
Taylor expanded in c around 0
Applied rewrites52.0%
Taylor expanded in c around inf
Applied rewrites28.3%
Taylor expanded in j around 0
Applied rewrites65.4%
Final simplification68.4%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -6e+151)
(* (* z x) y)
(if (<= z -7.2e-27)
(* (* j c) t)
(if (<= z -2.8e-166)
(* (* b a) i)
(if (<= z 420000000.0) (* (* j t) c) (* (* (- z) c) b))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -6e+151) {
tmp = (z * x) * y;
} else if (z <= -7.2e-27) {
tmp = (j * c) * t;
} else if (z <= -2.8e-166) {
tmp = (b * a) * i;
} else if (z <= 420000000.0) {
tmp = (j * t) * c;
} else {
tmp = (-z * c) * 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 (z <= (-6d+151)) then
tmp = (z * x) * y
else if (z <= (-7.2d-27)) then
tmp = (j * c) * t
else if (z <= (-2.8d-166)) then
tmp = (b * a) * i
else if (z <= 420000000.0d0) then
tmp = (j * t) * c
else
tmp = (-z * c) * 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 (z <= -6e+151) {
tmp = (z * x) * y;
} else if (z <= -7.2e-27) {
tmp = (j * c) * t;
} else if (z <= -2.8e-166) {
tmp = (b * a) * i;
} else if (z <= 420000000.0) {
tmp = (j * t) * c;
} else {
tmp = (-z * c) * b;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -6e+151: tmp = (z * x) * y elif z <= -7.2e-27: tmp = (j * c) * t elif z <= -2.8e-166: tmp = (b * a) * i elif z <= 420000000.0: tmp = (j * t) * c else: tmp = (-z * c) * b return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -6e+151) tmp = Float64(Float64(z * x) * y); elseif (z <= -7.2e-27) tmp = Float64(Float64(j * c) * t); elseif (z <= -2.8e-166) tmp = Float64(Float64(b * a) * i); elseif (z <= 420000000.0) tmp = Float64(Float64(j * t) * c); else tmp = Float64(Float64(Float64(-z) * c) * b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -6e+151) tmp = (z * x) * y; elseif (z <= -7.2e-27) tmp = (j * c) * t; elseif (z <= -2.8e-166) tmp = (b * a) * i; elseif (z <= 420000000.0) tmp = (j * t) * c; else tmp = (-z * c) * b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -6e+151], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, -7.2e-27], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, -2.8e-166], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[z, 420000000.0], N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision], N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6 \cdot 10^{+151}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;z \leq -7.2 \cdot 10^{-27}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;z \leq -2.8 \cdot 10^{-166}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;z \leq 420000000:\\
\;\;\;\;\left(j \cdot t\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b\\
\end{array}
\end{array}
if z < -5.9999999999999998e151Initial program 68.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.6
Applied rewrites60.6%
Taylor expanded in y around inf
Applied rewrites57.6%
Taylor expanded in a around 0
Applied rewrites57.7%
if -5.9999999999999998e151 < z < -7.1999999999999997e-27Initial program 69.0%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6441.6
Applied rewrites41.6%
Taylor expanded in c around inf
Applied rewrites38.2%
if -7.1999999999999997e-27 < z < -2.7999999999999999e-166Initial program 79.1%
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-*.f6464.1
Applied rewrites64.1%
Taylor expanded in b around inf
Applied rewrites51.7%
if -2.7999999999999999e-166 < z < 4.2e8Initial program 76.1%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6453.7
Applied rewrites53.7%
Taylor expanded in c around inf
Applied rewrites32.1%
Taylor expanded in c around inf
Applied rewrites32.5%
if 4.2e8 < z Initial program 61.7%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites64.0%
Taylor expanded in c around 0
Applied rewrites45.6%
Taylor expanded in c around inf
Applied rewrites47.3%
Final simplification42.0%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -6e+151)
(* (* z x) y)
(if (<= z -7.2e-27)
(* (* j c) t)
(if (<= z -2.8e-166)
(* (* b a) i)
(if (<= z 420000000.0) (* (* j t) c) (* (* (- b) c) z))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -6e+151) {
tmp = (z * x) * y;
} else if (z <= -7.2e-27) {
tmp = (j * c) * t;
} else if (z <= -2.8e-166) {
tmp = (b * a) * i;
} else if (z <= 420000000.0) {
tmp = (j * t) * c;
} else {
tmp = (-b * c) * z;
}
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 (z <= (-6d+151)) then
tmp = (z * x) * y
else if (z <= (-7.2d-27)) then
tmp = (j * c) * t
else if (z <= (-2.8d-166)) then
tmp = (b * a) * i
else if (z <= 420000000.0d0) then
tmp = (j * t) * c
else
tmp = (-b * c) * z
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 (z <= -6e+151) {
tmp = (z * x) * y;
} else if (z <= -7.2e-27) {
tmp = (j * c) * t;
} else if (z <= -2.8e-166) {
tmp = (b * a) * i;
} else if (z <= 420000000.0) {
tmp = (j * t) * c;
} else {
tmp = (-b * c) * z;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -6e+151: tmp = (z * x) * y elif z <= -7.2e-27: tmp = (j * c) * t elif z <= -2.8e-166: tmp = (b * a) * i elif z <= 420000000.0: tmp = (j * t) * c else: tmp = (-b * c) * z return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -6e+151) tmp = Float64(Float64(z * x) * y); elseif (z <= -7.2e-27) tmp = Float64(Float64(j * c) * t); elseif (z <= -2.8e-166) tmp = Float64(Float64(b * a) * i); elseif (z <= 420000000.0) tmp = Float64(Float64(j * t) * c); else tmp = Float64(Float64(Float64(-b) * c) * z); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -6e+151) tmp = (z * x) * y; elseif (z <= -7.2e-27) tmp = (j * c) * t; elseif (z <= -2.8e-166) tmp = (b * a) * i; elseif (z <= 420000000.0) tmp = (j * t) * c; else tmp = (-b * c) * z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -6e+151], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, -7.2e-27], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, -2.8e-166], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[z, 420000000.0], N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision], N[(N[((-b) * c), $MachinePrecision] * z), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6 \cdot 10^{+151}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;z \leq -7.2 \cdot 10^{-27}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;z \leq -2.8 \cdot 10^{-166}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;z \leq 420000000:\\
\;\;\;\;\left(j \cdot t\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-b\right) \cdot c\right) \cdot z\\
\end{array}
\end{array}
if z < -5.9999999999999998e151Initial program 68.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.6
Applied rewrites60.6%
Taylor expanded in y around inf
Applied rewrites57.6%
Taylor expanded in a around 0
Applied rewrites57.7%
if -5.9999999999999998e151 < z < -7.1999999999999997e-27Initial program 69.0%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6441.6
Applied rewrites41.6%
Taylor expanded in c around inf
Applied rewrites38.2%
if -7.1999999999999997e-27 < z < -2.7999999999999999e-166Initial program 79.1%
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-*.f6464.1
Applied rewrites64.1%
Taylor expanded in b around inf
Applied rewrites51.7%
if -2.7999999999999999e-166 < z < 4.2e8Initial program 76.1%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6453.7
Applied rewrites53.7%
Taylor expanded in c around inf
Applied rewrites32.1%
Taylor expanded in c around inf
Applied rewrites32.5%
if 4.2e8 < z Initial program 61.7%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites64.0%
Taylor expanded in c around inf
Applied rewrites47.2%
Final simplification42.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)))
(if (<= z -6e+151)
t_1
(if (<= z -4e-267)
(* (fma (- x) a (* j c)) t)
(if (<= z 128000000.0) (* (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(-b, c, (y * x)) * z;
double tmp;
if (z <= -6e+151) {
tmp = t_1;
} else if (z <= -4e-267) {
tmp = fma(-x, a, (j * c)) * t;
} else if (z <= 128000000.0) {
tmp = 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(-b), c, Float64(y * x)) * z) tmp = 0.0 if (z <= -6e+151) tmp = t_1; elseif (z <= -4e-267) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); elseif (z <= 128000000.0) tmp = 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[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -6e+151], t$95$1, If[LessEqual[z, -4e-267], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, 128000000.0], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $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 -6 \cdot 10^{+151}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -4 \cdot 10^{-267}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{elif}\;z \leq 128000000:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.9999999999999998e151 or 1.28e8 < z Initial program 64.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
lower-*.f6474.1
Applied rewrites74.1%
if -5.9999999999999998e151 < z < -3.9999999999999999e-267Initial program 75.6%
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
lower-*.f6454.2
Applied rewrites54.2%
if -3.9999999999999999e-267 < z < 1.28e8Initial program 74.3%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6459.6
Applied rewrites59.6%
Final simplification63.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) z (* j t)) c)))
(if (<= c -0.0018)
t_1
(if (<= c -1.15e-289)
(* (fma (- a) t (* z y)) x)
(if (<= c 4.2e-60) (* (fma b a (* (- y) j)) 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(-b, z, (j * t)) * c;
double tmp;
if (c <= -0.0018) {
tmp = t_1;
} else if (c <= -1.15e-289) {
tmp = fma(-a, t, (z * y)) * x;
} else if (c <= 4.2e-60) {
tmp = fma(b, a, (-y * j)) * i;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), z, Float64(j * t)) * c) tmp = 0.0 if (c <= -0.0018) tmp = t_1; elseif (c <= -1.15e-289) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * x); elseif (c <= 4.2e-60) tmp = Float64(fma(b, a, Float64(Float64(-y) * j)) * 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[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]}, If[LessEqual[c, -0.0018], t$95$1, If[LessEqual[c, -1.15e-289], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[c, 4.2e-60], N[(N[(b * a + N[((-y) * j), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{if}\;c \leq -0.0018:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq -1.15 \cdot 10^{-289}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{elif}\;c \leq 4.2 \cdot 10^{-60}:\\
\;\;\;\;\mathsf{fma}\left(b, a, \left(-y\right) \cdot j\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -0.0018 or 4.19999999999999982e-60 < c Initial program 63.0%
Taylor expanded in c 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-*.f6465.2
Applied rewrites65.2%
if -0.0018 < c < -1.1500000000000001e-289Initial program 78.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.9
Applied rewrites50.9%
if -1.1500000000000001e-289 < c < 4.19999999999999982e-60Initial program 81.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-*.f6460.5
Applied rewrites60.5%
Applied rewrites58.8%
Final simplification60.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -2.2e+76)
(* (fma (- a) t (* z y)) x)
(if (<= x -35000000000000.0)
(* (* j c) t)
(if (<= x 2.4e-64)
(* (fma b a (* (- y) j)) i)
(* (fma z y (* (- a) t)) 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 <= -2.2e+76) {
tmp = fma(-a, t, (z * y)) * x;
} else if (x <= -35000000000000.0) {
tmp = (j * c) * t;
} else if (x <= 2.4e-64) {
tmp = fma(b, a, (-y * j)) * i;
} else {
tmp = fma(z, y, (-a * t)) * x;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -2.2e+76) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * x); elseif (x <= -35000000000000.0) tmp = Float64(Float64(j * c) * t); elseif (x <= 2.4e-64) tmp = Float64(fma(b, a, Float64(Float64(-y) * j)) * i); else tmp = Float64(fma(z, y, Float64(Float64(-a) * t)) * x); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -2.2e+76], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[x, -35000000000000.0], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 2.4e-64], N[(N[(b * a + N[((-y) * j), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], N[(N[(z * y + N[((-a) * t), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.2 \cdot 10^{+76}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{elif}\;x \leq -35000000000000:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 2.4 \cdot 10^{-64}:\\
\;\;\;\;\mathsf{fma}\left(b, a, \left(-y\right) \cdot j\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z, y, \left(-a\right) \cdot t\right) \cdot x\\
\end{array}
\end{array}
if x < -2.2e76Initial program 61.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6459.9
Applied rewrites59.9%
if -2.2e76 < x < -3.5e13Initial program 81.0%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6469.3
Applied rewrites69.3%
Taylor expanded in c around inf
Applied rewrites63.1%
if -3.5e13 < x < 2.39999999999999998e-64Initial program 69.2%
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-*.f6446.3
Applied rewrites46.3%
Applied rewrites46.3%
if 2.39999999999999998e-64 < x Initial program 75.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6455.5
Applied rewrites55.5%
Applied rewrites55.5%
Final simplification52.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma z y (* (- a) t)) x)))
(if (<= x -2.2e+76)
t_1
(if (<= x -35000000000000.0)
(* (* j c) t)
(if (<= x 2.4e-64) (* (fma b a (* (- y) j)) 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(z, y, (-a * t)) * x;
double tmp;
if (x <= -2.2e+76) {
tmp = t_1;
} else if (x <= -35000000000000.0) {
tmp = (j * c) * t;
} else if (x <= 2.4e-64) {
tmp = fma(b, a, (-y * j)) * i;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(z, y, Float64(Float64(-a) * t)) * x) tmp = 0.0 if (x <= -2.2e+76) tmp = t_1; elseif (x <= -35000000000000.0) tmp = Float64(Float64(j * c) * t); elseif (x <= 2.4e-64) tmp = Float64(fma(b, a, Float64(Float64(-y) * j)) * 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[(z * y + N[((-a) * t), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.2e+76], t$95$1, If[LessEqual[x, -35000000000000.0], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 2.4e-64], N[(N[(b * a + N[((-y) * j), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(z, y, \left(-a\right) \cdot t\right) \cdot x\\
\mathbf{if}\;x \leq -2.2 \cdot 10^{+76}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -35000000000000:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 2.4 \cdot 10^{-64}:\\
\;\;\;\;\mathsf{fma}\left(b, a, \left(-y\right) \cdot j\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.2e76 or 2.39999999999999998e-64 < x Initial program 71.5%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.8
Applied rewrites56.8%
Applied rewrites56.0%
if -2.2e76 < x < -3.5e13Initial program 81.0%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6469.3
Applied rewrites69.3%
Taylor expanded in c around inf
Applied rewrites63.1%
if -3.5e13 < x < 2.39999999999999998e-64Initial program 69.2%
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-*.f6446.3
Applied rewrites46.3%
Applied rewrites46.3%
Final simplification52.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- z) c) b)))
(if (<= z -2.05e+151)
(* (* z x) y)
(if (<= z -2.1e+133)
t_1
(if (<= z 490000000.0) (* (fma b a (* (- y) j)) 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 = (-z * c) * b;
double tmp;
if (z <= -2.05e+151) {
tmp = (z * x) * y;
} else if (z <= -2.1e+133) {
tmp = t_1;
} else if (z <= 490000000.0) {
tmp = fma(b, a, (-y * j)) * i;
} 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 (z <= -2.05e+151) tmp = Float64(Float64(z * x) * y); elseif (z <= -2.1e+133) tmp = t_1; elseif (z <= 490000000.0) tmp = Float64(fma(b, a, Float64(Float64(-y) * j)) * 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[((-z) * c), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[z, -2.05e+151], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, -2.1e+133], t$95$1, If[LessEqual[z, 490000000.0], N[(N[(b * a + N[((-y) * j), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{if}\;z \leq -2.05 \cdot 10^{+151}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;z \leq -2.1 \cdot 10^{+133}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 490000000:\\
\;\;\;\;\mathsf{fma}\left(b, a, \left(-y\right) \cdot j\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.0499999999999999e151Initial program 68.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6459.1
Applied rewrites59.1%
Taylor expanded in y around inf
Applied rewrites56.1%
Taylor expanded in a around 0
Applied rewrites56.2%
if -2.0499999999999999e151 < z < -2.1e133 or 4.9e8 < z Initial program 62.8%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites63.3%
Taylor expanded in c around 0
Applied rewrites40.9%
Taylor expanded in c around inf
Applied rewrites50.0%
if -2.1e133 < z < 4.9e8Initial program 75.0%
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-*.f6444.4
Applied rewrites44.4%
Applied rewrites44.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)))
(if (<= z -2.45e+45)
t_1
(if (<= z 2.1e-9) (* (fma b a (* (- y) j)) 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(-b, c, (y * x)) * z;
double tmp;
if (z <= -2.45e+45) {
tmp = t_1;
} else if (z <= 2.1e-9) {
tmp = fma(b, a, (-y * j)) * i;
} 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 <= -2.45e+45) tmp = t_1; elseif (z <= 2.1e-9) tmp = Float64(fma(b, a, Float64(Float64(-y) * j)) * 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[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -2.45e+45], t$95$1, If[LessEqual[z, 2.1e-9], N[(N[(b * a + N[((-y) * j), $MachinePrecision]), $MachinePrecision] * i), $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 -2.45 \cdot 10^{+45}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2.1 \cdot 10^{-9}:\\
\;\;\;\;\mathsf{fma}\left(b, a, \left(-y\right) \cdot j\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.4500000000000001e45 or 2.10000000000000019e-9 < z Initial program 65.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
lower-*.f6465.9
Applied rewrites65.9%
if -2.4500000000000001e45 < z < 2.10000000000000019e-9Initial program 75.9%
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-*.f6447.2
Applied rewrites47.2%
Applied rewrites47.2%
Final simplification56.3%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= z -6e+151) (* (* z x) y) (if (<= z 8e+105) (* (* j c) 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 tmp;
if (z <= -6e+151) {
tmp = (z * x) * y;
} else if (z <= 8e+105) {
tmp = (j * c) * t;
} 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 (z <= (-6d+151)) then
tmp = (z * x) * y
else if (z <= 8d+105) then
tmp = (j * c) * t
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 (z <= -6e+151) {
tmp = (z * x) * y;
} else if (z <= 8e+105) {
tmp = (j * c) * t;
} else {
tmp = (z * y) * x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -6e+151: tmp = (z * x) * y elif z <= 8e+105: tmp = (j * c) * t else: tmp = (z * y) * x return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -6e+151) tmp = Float64(Float64(z * x) * y); elseif (z <= 8e+105) tmp = Float64(Float64(j * c) * t); 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 (z <= -6e+151) tmp = (z * x) * y; elseif (z <= 8e+105) tmp = (j * c) * t; else tmp = (z * y) * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -6e+151], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, 8e+105], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6 \cdot 10^{+151}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;z \leq 8 \cdot 10^{+105}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\end{array}
\end{array}
if z < -5.9999999999999998e151Initial program 68.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.6
Applied rewrites60.6%
Taylor expanded in y around inf
Applied rewrites57.6%
Taylor expanded in a around 0
Applied rewrites57.7%
if -5.9999999999999998e151 < z < 7.9999999999999995e105Initial program 73.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6446.0
Applied rewrites46.0%
Taylor expanded in c around inf
Applied rewrites31.8%
if 7.9999999999999995e105 < z Initial program 61.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.2
Applied rewrites52.2%
Taylor expanded in a around 0
Applied rewrites49.9%
Final simplification38.3%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* z x) y))) (if (<= z -6e+151) t_1 (if (<= z 7.8e+105) (* (* j c) t) 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 * x) * y;
double tmp;
if (z <= -6e+151) {
tmp = t_1;
} else if (z <= 7.8e+105) {
tmp = (j * c) * t;
} 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 * x) * y
if (z <= (-6d+151)) then
tmp = t_1
else if (z <= 7.8d+105) then
tmp = (j * c) * t
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 * x) * y;
double tmp;
if (z <= -6e+151) {
tmp = t_1;
} else if (z <= 7.8e+105) {
tmp = (j * c) * t;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (z * x) * y tmp = 0 if z <= -6e+151: tmp = t_1 elif z <= 7.8e+105: tmp = (j * c) * t else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(z * x) * y) tmp = 0.0 if (z <= -6e+151) tmp = t_1; elseif (z <= 7.8e+105) tmp = Float64(Float64(j * c) * t); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (z * x) * y; tmp = 0.0; if (z <= -6e+151) tmp = t_1; elseif (z <= 7.8e+105) tmp = (j * c) * t; 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 * x), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[z, -6e+151], t$95$1, If[LessEqual[z, 7.8e+105], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot x\right) \cdot y\\
\mathbf{if}\;z \leq -6 \cdot 10^{+151}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 7.8 \cdot 10^{+105}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -5.9999999999999998e151 or 7.79999999999999957e105 < z Initial program 64.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.3
Applied rewrites56.3%
Taylor expanded in y around inf
Applied rewrites44.6%
Taylor expanded in a around 0
Applied rewrites51.3%
if -5.9999999999999998e151 < z < 7.79999999999999957e105Initial program 73.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6446.0
Applied rewrites46.0%
Taylor expanded in c around inf
Applied rewrites31.8%
Final simplification37.6%
(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 71.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6435.0
Applied rewrites35.0%
Taylor expanded in y around inf
Applied rewrites32.0%
Taylor expanded in a around 0
Applied rewrites20.5%
(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 2024268
(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)))))