
(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 21 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 INFINITY) t_1 (fma (fma (- j) y (* b a)) i (* (* (- c) b) z)))))
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 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(fma(-j, y, (b * a)), i, ((-c * b) * z));
}
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 <= Inf) tmp = t_1; else tmp = fma(fma(Float64(-j), y, Float64(b * a)), i, Float64(Float64(Float64(-c) * b) * z)); 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, Infinity], t$95$1, N[(N[((-j) * y + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * b), $MachinePrecision] * z), $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 \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-j, y, b \cdot a\right), i, \left(\left(-c\right) \cdot b\right) \cdot z\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 93.0%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in a around 0
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 rewrites31.6%
Taylor expanded in t around 0
Applied rewrites64.6%
Taylor expanded in c around inf
Applied rewrites73.0%
Final simplification89.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<=
(-
(* (- (* c t) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b)))
INFINITY)
(fma
(fma (- x) t (* i b))
a
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j)))
(fma (fma (- j) y (* b a)) i (* (* (- c) b) z))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (((((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b))) <= ((double) INFINITY)) {
tmp = fma(fma(-x, t, (i * b)), a, fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j)));
} else {
tmp = fma(fma(-j, y, (b * a)), i, ((-c * b) * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b))) <= Inf) tmp = fma(fma(Float64(-x), t, Float64(i * b)), a, fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j))); else tmp = fma(fma(Float64(-j), y, Float64(b * a)), i, Float64(Float64(Float64(-c) * b) * z)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-j) * y + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * b), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(c \cdot t - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\right) \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, t, i \cdot b\right), a, \mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-j, y, b \cdot a\right), i, \left(\left(-c\right) \cdot b\right) \cdot z\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 93.0%
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 rewrites87.8%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in a around 0
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 rewrites31.6%
Taylor expanded in t around 0
Applied rewrites64.6%
Taylor expanded in c around inf
Applied rewrites73.0%
Final simplification85.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (- c) z (* i a)))
(t_2 (fma t_1 b (* (fma (- a) t (* z y)) x))))
(if (<= x -2.4e+40)
t_2
(if (<= x 3e+50)
(fma (fma (- x) a (* j c)) t (fma (fma (- j) i (* z x)) y (* t_1 b)))
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(-c, z, (i * a));
double t_2 = fma(t_1, b, (fma(-a, t, (z * y)) * x));
double tmp;
if (x <= -2.4e+40) {
tmp = t_2;
} else if (x <= 3e+50) {
tmp = fma(fma(-x, a, (j * c)), t, fma(fma(-j, i, (z * x)), y, (t_1 * b)));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(-c), z, Float64(i * a)) t_2 = fma(t_1, b, Float64(fma(Float64(-a), t, Float64(z * y)) * x)) tmp = 0.0 if (x <= -2.4e+40) tmp = t_2; elseif (x <= 3e+50) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(t_1 * b))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * b + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.4e+40], t$95$2, If[LessEqual[x, 3e+50], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(t$95$1 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, z, i \cdot a\right)\\
t_2 := \mathsf{fma}\left(t\_1, b, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{if}\;x \leq -2.4 \cdot 10^{+40}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 3 \cdot 10^{+50}:\\
\;\;\;\;\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, t\_1 \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -2.4e40 or 2.9999999999999998e50 < x Initial program 77.4%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites80.9%
if -2.4e40 < x < 2.9999999999999998e50Initial program 74.2%
Taylor expanded in t around 0
Applied rewrites84.4%
Final simplification82.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- c) z (* i a)) b (* (fma (- a) t (* z y)) x))))
(if (<= x -4e-34)
t_1
(if (<= x 2.9e-123)
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j))
(if (<= x 2.3e-10)
(fma (fma (- j) y (* b a)) i (* (* (- c) b) 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(fma(-c, z, (i * a)), b, (fma(-a, t, (z * y)) * x));
double tmp;
if (x <= -4e-34) {
tmp = t_1;
} else if (x <= 2.9e-123) {
tmp = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
} else if (x <= 2.3e-10) {
tmp = fma(fma(-j, y, (b * a)), i, ((-c * b) * z));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-c), z, Float64(i * a)), b, Float64(fma(Float64(-a), t, Float64(z * y)) * x)) tmp = 0.0 if (x <= -4e-34) tmp = t_1; elseif (x <= 2.9e-123) tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); elseif (x <= 2.3e-10) tmp = fma(fma(Float64(-j), y, Float64(b * a)), i, Float64(Float64(Float64(-c) * b) * 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[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4e-34], t$95$1, If[LessEqual[x, 2.9e-123], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.3e-10], N[(N[((-j) * y + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * b), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-c, z, i \cdot a\right), b, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{if}\;x \leq -4 \cdot 10^{-34}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2.9 \cdot 10^{-123}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{elif}\;x \leq 2.3 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-j, y, b \cdot a\right), i, \left(\left(-c\right) \cdot b\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.99999999999999971e-34 or 2.30000000000000007e-10 < x Initial program 75.5%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites79.7%
if -3.99999999999999971e-34 < x < 2.90000000000000004e-123Initial program 77.5%
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.6%
if 2.90000000000000004e-123 < x < 2.30000000000000007e-10Initial program 69.5%
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 rewrites80.6%
Taylor expanded in t around 0
Applied rewrites88.9%
Taylor expanded in c around inf
Applied rewrites89.3%
Final simplification78.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- y) i (* c t)) j (* (fma (- c) b (* y x)) z))))
(if (<= j -8.5e+156)
t_1
(if (<= j 6e+79)
(fma (fma (- c) z (* i a)) b (* (fma (- a) t (* 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 = fma(fma(-y, i, (c * t)), j, (fma(-c, b, (y * x)) * z));
double tmp;
if (j <= -8.5e+156) {
tmp = t_1;
} else if (j <= 6e+79) {
tmp = fma(fma(-c, z, (i * a)), b, (fma(-a, t, (z * y)) * x));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-y), i, Float64(c * t)), j, Float64(fma(Float64(-c), b, Float64(y * x)) * z)) tmp = 0.0 if (j <= -8.5e+156) tmp = t_1; elseif (j <= 6e+79) tmp = fma(fma(Float64(-c), z, Float64(i * a)), b, Float64(fma(Float64(-a), t, Float64(z * y)) * 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[((-y) * i + N[(c * t), $MachinePrecision]), $MachinePrecision] * j + N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -8.5e+156], t$95$1, If[LessEqual[j, 6e+79], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-y, i, c \cdot t\right), j, \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\right)\\
\mathbf{if}\;j \leq -8.5 \cdot 10^{+156}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 6 \cdot 10^{+79}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, z, i \cdot a\right), b, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -8.49999999999999948e156 or 5.99999999999999948e79 < j Initial program 70.5%
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-/.f6470.5
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6470.5
Applied rewrites70.5%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6438.5
Applied rewrites38.5%
Taylor expanded in a around 0
associate--l+N/A
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
cancel-sign-sub-invN/A
associate-*r*N/A
mul-1-negN/A
distribute-rgt-inN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites76.7%
if -8.49999999999999948e156 < j < 5.99999999999999948e79Initial program 77.9%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites76.9%
Final simplification76.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (* i a) b (* (fma (- a) t (* z y)) x))))
(if (<= x -2.7e+72)
t_1
(if (<= x 9.8e+82)
(fma (fma (- j) y (* 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 * a), b, (fma(-a, t, (z * y)) * x));
double tmp;
if (x <= -2.7e+72) {
tmp = t_1;
} else if (x <= 9.8e+82) {
tmp = fma(fma(-j, y, (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 = fma(Float64(i * a), b, Float64(fma(Float64(-a), t, Float64(z * y)) * x)) tmp = 0.0 if (x <= -2.7e+72) tmp = t_1; elseif (x <= 9.8e+82) tmp = fma(fma(Float64(-j), y, 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 * a), $MachinePrecision] * b + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.7e+72], t$95$1, If[LessEqual[x, 9.8e+82], N[(N[((-j) * y + 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(i \cdot a, b, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{if}\;x \leq -2.7 \cdot 10^{+72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 9.8 \cdot 10^{+82}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-j, y, 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 x < -2.7000000000000001e72 or 9.8000000000000001e82 < x Initial program 78.2%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites81.0%
Taylor expanded in c around 0
Applied rewrites75.1%
if -2.7000000000000001e72 < x < 9.8000000000000001e82Initial program 73.9%
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 rewrites82.2%
Taylor expanded in t around 0
Applied rewrites72.0%
Final simplification73.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.25e+190)
t_1
(if (<= j -5.5e-110)
(fma (fma (- c) z (* i a)) b (* (* z y) x))
(if (<= j 2.1e+85) (fma (* i a) b (* (fma (- a) t (* 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 = fma(-i, y, (c * t)) * j;
double tmp;
if (j <= -2.25e+190) {
tmp = t_1;
} else if (j <= -5.5e-110) {
tmp = fma(fma(-c, z, (i * a)), b, ((z * y) * x));
} else if (j <= 2.1e+85) {
tmp = fma((i * a), b, (fma(-a, t, (z * y)) * x));
} 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.25e+190) tmp = t_1; elseif (j <= -5.5e-110) tmp = fma(fma(Float64(-c), z, Float64(i * a)), b, Float64(Float64(z * y) * x)); elseif (j <= 2.1e+85) tmp = fma(Float64(i * a), b, Float64(fma(Float64(-a), t, Float64(z * y)) * 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[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -2.25e+190], t$95$1, If[LessEqual[j, -5.5e-110], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.1e+85], N[(N[(i * a), $MachinePrecision] * b + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $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.25 \cdot 10^{+190}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -5.5 \cdot 10^{-110}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, z, i \cdot a\right), b, \left(z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;j \leq 2.1 \cdot 10^{+85}:\\
\;\;\;\;\mathsf{fma}\left(i \cdot a, b, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -2.25e190 or 2.1000000000000001e85 < j Initial program 69.5%
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-*.f6467.1
Applied rewrites67.1%
if -2.25e190 < j < -5.4999999999999998e-110Initial program 78.5%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites72.3%
Taylor expanded in a around 0
Applied rewrites66.7%
if -5.4999999999999998e-110 < j < 2.1000000000000001e85Initial program 77.9%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites79.0%
Taylor expanded in c around 0
Applied rewrites70.2%
Final simplification68.4%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= b -3.4e+57)
(* (fma (- c) z (* i a)) b)
(if (<= b -1.56e-200)
(* (fma (- a) t (* z y)) x)
(if (<= b 3.6e-66)
(* (fma (- j) i (* z x)) y)
(fma (* b a) i (* (fma (- c) b (* 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 (b <= -3.4e+57) {
tmp = fma(-c, z, (i * a)) * b;
} else if (b <= -1.56e-200) {
tmp = fma(-a, t, (z * y)) * x;
} else if (b <= 3.6e-66) {
tmp = fma(-j, i, (z * x)) * y;
} else {
tmp = fma((b * a), i, (fma(-c, b, (y * x)) * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -3.4e+57) tmp = Float64(fma(Float64(-c), z, Float64(i * a)) * b); elseif (b <= -1.56e-200) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * x); elseif (b <= 3.6e-66) tmp = Float64(fma(Float64(-j), i, Float64(z * x)) * y); else tmp = fma(Float64(b * a), i, Float64(fma(Float64(-c), b, Float64(y * x)) * z)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -3.4e+57], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[b, -1.56e-200], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 3.6e-66], N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], N[(N[(b * a), $MachinePrecision] * i + N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.4 \cdot 10^{+57}:\\
\;\;\;\;\mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{elif}\;b \leq -1.56 \cdot 10^{-200}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{elif}\;b \leq 3.6 \cdot 10^{-66}:\\
\;\;\;\;\mathsf{fma}\left(-j, i, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(b \cdot a, i, \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\right)\\
\end{array}
\end{array}
if b < -3.39999999999999992e57Initial program 73.3%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6474.3
Applied rewrites74.3%
if -3.39999999999999992e57 < b < -1.5600000000000001e-200Initial program 70.4%
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-*.f6462.5
Applied rewrites62.5%
if -1.5600000000000001e-200 < b < 3.60000000000000012e-66Initial program 73.7%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.2
Applied rewrites60.2%
if 3.60000000000000012e-66 < b Initial program 81.8%
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 rewrites84.1%
Taylor expanded in t around 0
Applied rewrites77.0%
Taylor expanded in b around inf
Applied rewrites67.6%
Final simplification66.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (* i a) b (* (fma (- a) t (* z y)) x))))
(if (<= x -4.8e+66)
t_1
(if (<= x 2.25e+78)
(fma (fma (- j) y (* b a)) i (* (* (- c) b) 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 * a), b, (fma(-a, t, (z * y)) * x));
double tmp;
if (x <= -4.8e+66) {
tmp = t_1;
} else if (x <= 2.25e+78) {
tmp = fma(fma(-j, y, (b * a)), i, ((-c * b) * z));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(i * a), b, Float64(fma(Float64(-a), t, Float64(z * y)) * x)) tmp = 0.0 if (x <= -4.8e+66) tmp = t_1; elseif (x <= 2.25e+78) tmp = fma(fma(Float64(-j), y, Float64(b * a)), i, Float64(Float64(Float64(-c) * b) * 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 * a), $MachinePrecision] * b + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4.8e+66], t$95$1, If[LessEqual[x, 2.25e+78], N[(N[((-j) * y + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * b), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(i \cdot a, b, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{if}\;x \leq -4.8 \cdot 10^{+66}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2.25 \cdot 10^{+78}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-j, y, b \cdot a\right), i, \left(\left(-c\right) \cdot b\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.8000000000000003e66 or 2.25e78 < x Initial program 78.2%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites81.0%
Taylor expanded in c around 0
Applied rewrites75.1%
if -4.8000000000000003e66 < x < 2.25e78Initial program 73.9%
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 rewrites82.2%
Taylor expanded in t around 0
Applied rewrites72.0%
Taylor expanded in c around inf
Applied rewrites68.4%
Final simplification71.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) y (* c t)) j)))
(if (<= j -3e+158)
t_1
(if (<= j 2.1e+85) (fma (* i a) b (* (fma (- a) t (* 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 = fma(-i, y, (c * t)) * j;
double tmp;
if (j <= -3e+158) {
tmp = t_1;
} else if (j <= 2.1e+85) {
tmp = fma((i * a), b, (fma(-a, t, (z * y)) * x));
} 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 <= -3e+158) tmp = t_1; elseif (j <= 2.1e+85) tmp = fma(Float64(i * a), b, Float64(fma(Float64(-a), t, Float64(z * y)) * 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[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -3e+158], t$95$1, If[LessEqual[j, 2.1e+85], N[(N[(i * a), $MachinePrecision] * b + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $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 -3 \cdot 10^{+158}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 2.1 \cdot 10^{+85}:\\
\;\;\;\;\mathsf{fma}\left(i \cdot a, b, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -3e158 or 2.1000000000000001e85 < j Initial program 69.8%
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-*.f6467.5
Applied rewrites67.5%
if -3e158 < j < 2.1000000000000001e85Initial program 78.2%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites77.2%
Taylor expanded in c around 0
Applied rewrites65.5%
Final simplification66.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- c) b) z)))
(if (<= b -1.5e+129)
t_1
(if (<= b -1.5e+25)
(* (* b a) i)
(if (<= b -6.2e-229)
(* (* z y) x)
(if (<= b 2.7e+83) (* (* (- y) i) 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 = (-c * b) * z;
double tmp;
if (b <= -1.5e+129) {
tmp = t_1;
} else if (b <= -1.5e+25) {
tmp = (b * a) * i;
} else if (b <= -6.2e-229) {
tmp = (z * y) * x;
} else if (b <= 2.7e+83) {
tmp = (-y * i) * j;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (-c * b) * z
if (b <= (-1.5d+129)) then
tmp = t_1
else if (b <= (-1.5d+25)) then
tmp = (b * a) * i
else if (b <= (-6.2d-229)) then
tmp = (z * y) * x
else if (b <= 2.7d+83) then
tmp = (-y * i) * j
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-c * b) * z;
double tmp;
if (b <= -1.5e+129) {
tmp = t_1;
} else if (b <= -1.5e+25) {
tmp = (b * a) * i;
} else if (b <= -6.2e-229) {
tmp = (z * y) * x;
} else if (b <= 2.7e+83) {
tmp = (-y * i) * j;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-c * b) * z tmp = 0 if b <= -1.5e+129: tmp = t_1 elif b <= -1.5e+25: tmp = (b * a) * i elif b <= -6.2e-229: tmp = (z * y) * x elif b <= 2.7e+83: tmp = (-y * i) * j else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-c) * b) * z) tmp = 0.0 if (b <= -1.5e+129) tmp = t_1; elseif (b <= -1.5e+25) tmp = Float64(Float64(b * a) * i); elseif (b <= -6.2e-229) tmp = Float64(Float64(z * y) * x); elseif (b <= 2.7e+83) tmp = Float64(Float64(Float64(-y) * i) * j); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-c * b) * z; tmp = 0.0; if (b <= -1.5e+129) tmp = t_1; elseif (b <= -1.5e+25) tmp = (b * a) * i; elseif (b <= -6.2e-229) tmp = (z * y) * x; elseif (b <= 2.7e+83) tmp = (-y * i) * j; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-c) * b), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[b, -1.5e+129], t$95$1, If[LessEqual[b, -1.5e+25], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[b, -6.2e-229], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 2.7e+83], N[(N[((-y) * i), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-c\right) \cdot b\right) \cdot z\\
\mathbf{if}\;b \leq -1.5 \cdot 10^{+129}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.5 \cdot 10^{+25}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;b \leq -6.2 \cdot 10^{-229}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{elif}\;b \leq 2.7 \cdot 10^{+83}:\\
\;\;\;\;\left(\left(-y\right) \cdot i\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.50000000000000015e129 or 2.70000000000000007e83 < b Initial program 71.5%
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 rewrites70.3%
Taylor expanded in z around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/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-*.f6456.3
Applied rewrites56.3%
Taylor expanded in c around inf
Applied rewrites51.7%
if -1.50000000000000015e129 < b < -1.50000000000000003e25Initial program 91.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-*.f6457.5
Applied rewrites57.5%
Taylor expanded in b around inf
Applied rewrites53.2%
if -1.50000000000000003e25 < b < -6.2000000000000002e-229Initial program 71.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-*.f6461.6
Applied rewrites61.6%
Taylor expanded in a around 0
Applied rewrites38.3%
if -6.2000000000000002e-229 < b < 2.70000000000000007e83Initial program 77.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-*.f6446.3
Applied rewrites46.3%
Taylor expanded in c around 0
Applied rewrites34.8%
Final simplification42.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) z (* i a)) b)))
(if (<= b -3.4e+57)
t_1
(if (<= b -1.56e-200)
(* (fma (- a) t (* z y)) x)
(if (<= b 1e+53) (* (fma (- j) i (* z x)) y) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-c, z, (i * a)) * b;
double tmp;
if (b <= -3.4e+57) {
tmp = t_1;
} else if (b <= -1.56e-200) {
tmp = fma(-a, t, (z * y)) * x;
} else if (b <= 1e+53) {
tmp = fma(-j, i, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), z, Float64(i * a)) * b) tmp = 0.0 if (b <= -3.4e+57) tmp = t_1; elseif (b <= -1.56e-200) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * x); elseif (b <= 1e+53) tmp = Float64(fma(Float64(-j), i, Float64(z * x)) * y); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -3.4e+57], t$95$1, If[LessEqual[b, -1.56e-200], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 1e+53], N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -3.4 \cdot 10^{+57}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.56 \cdot 10^{-200}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{elif}\;b \leq 10^{+53}:\\
\;\;\;\;\mathsf{fma}\left(-j, i, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -3.39999999999999992e57 or 9.9999999999999999e52 < b Initial program 76.8%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6472.4
Applied rewrites72.4%
if -3.39999999999999992e57 < b < -1.5600000000000001e-200Initial program 70.4%
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-*.f6462.5
Applied rewrites62.5%
if -1.5600000000000001e-200 < b < 9.9999999999999999e52Initial program 76.7%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.4
Applied rewrites56.4%
Final simplification64.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)))
(if (<= b -1.45e+129)
t_1
(if (<= b -2.2e+60)
(* (* b a) i)
(if (<= b 3.2e+14) (* (fma (- a) t (* 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 = fma(-b, c, (y * x)) * z;
double tmp;
if (b <= -1.45e+129) {
tmp = t_1;
} else if (b <= -2.2e+60) {
tmp = (b * a) * i;
} else if (b <= 3.2e+14) {
tmp = fma(-a, t, (z * y)) * x;
} 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 (b <= -1.45e+129) tmp = t_1; elseif (b <= -2.2e+60) tmp = Float64(Float64(b * a) * i); elseif (b <= 3.2e+14) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * 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[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[b, -1.45e+129], t$95$1, If[LessEqual[b, -2.2e+60], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[b, 3.2e+14], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $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}\;b \leq -1.45 \cdot 10^{+129}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -2.2 \cdot 10^{+60}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;b \leq 3.2 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.45000000000000001e129 or 3.2e14 < b Initial program 72.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6453.9
Applied rewrites53.9%
if -1.45000000000000001e129 < b < -2.19999999999999996e60Initial program 93.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-*.f6459.8
Applied rewrites59.8%
Taylor expanded in b around inf
Applied rewrites54.1%
if -2.19999999999999996e60 < b < 3.2e14Initial program 75.7%
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-*.f6453.9
Applied rewrites53.9%
Final simplification53.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- c) b) z)))
(if (<= b -1.5e+129)
t_1
(if (<= b -2.2e+60)
(* (* b a) i)
(if (<= b 2.4e+64) (* (fma (- a) t (* 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 = (-c * b) * z;
double tmp;
if (b <= -1.5e+129) {
tmp = t_1;
} else if (b <= -2.2e+60) {
tmp = (b * a) * i;
} else if (b <= 2.4e+64) {
tmp = fma(-a, t, (z * y)) * x;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-c) * b) * z) tmp = 0.0 if (b <= -1.5e+129) tmp = t_1; elseif (b <= -2.2e+60) tmp = Float64(Float64(b * a) * i); elseif (b <= 2.4e+64) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * 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[((-c) * b), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[b, -1.5e+129], t$95$1, If[LessEqual[b, -2.2e+60], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[b, 2.4e+64], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-c\right) \cdot b\right) \cdot z\\
\mathbf{if}\;b \leq -1.5 \cdot 10^{+129}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -2.2 \cdot 10^{+60}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;b \leq 2.4 \cdot 10^{+64}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.50000000000000015e129 or 2.39999999999999999e64 < b Initial program 72.3%
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 rewrites71.2%
Taylor expanded in z around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/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-*.f6454.8
Applied rewrites54.8%
Taylor expanded in c around inf
Applied rewrites50.5%
if -1.50000000000000015e129 < b < -2.19999999999999996e60Initial program 93.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-*.f6459.8
Applied rewrites59.8%
Taylor expanded in b around inf
Applied rewrites54.1%
if -2.19999999999999996e60 < b < 2.39999999999999999e64Initial program 75.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-*.f6452.8
Applied rewrites52.8%
Final simplification52.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) z (* i a)) b)))
(if (<= b -3.4e+57)
t_1
(if (<= b 1.35e+53) (* (fma (- a) t (* 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 = fma(-c, z, (i * a)) * b;
double tmp;
if (b <= -3.4e+57) {
tmp = t_1;
} else if (b <= 1.35e+53) {
tmp = fma(-a, t, (z * y)) * x;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), z, Float64(i * a)) * b) tmp = 0.0 if (b <= -3.4e+57) tmp = t_1; elseif (b <= 1.35e+53) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * 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[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -3.4e+57], t$95$1, If[LessEqual[b, 1.35e+53], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -3.4 \cdot 10^{+57}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.35 \cdot 10^{+53}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -3.39999999999999992e57 or 1.3500000000000001e53 < b Initial program 76.8%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6472.4
Applied rewrites72.4%
if -3.39999999999999992e57 < b < 1.3500000000000001e53Initial program 74.7%
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-*.f6454.5
Applied rewrites54.5%
Final simplification62.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= b -8.2e+57)
(* (fma (- b) z (* j t)) c)
(if (<= b 3.2e+14)
(* (fma (- a) t (* z y)) x)
(* (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 (b <= -8.2e+57) {
tmp = fma(-b, z, (j * t)) * c;
} else if (b <= 3.2e+14) {
tmp = fma(-a, t, (z * y)) * x;
} else {
tmp = fma(-b, c, (y * x)) * z;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -8.2e+57) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); elseif (b <= 3.2e+14) tmp = Float64(fma(Float64(-a), t, Float64(z * y)) * x); else tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -8.2e+57], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[b, 3.2e+14], N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -8.2 \cdot 10^{+57}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{elif}\;b \leq 3.2 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\end{array}
\end{array}
if b < -8.2e57Initial program 73.3%
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-*.f6452.5
Applied rewrites52.5%
if -8.2e57 < b < 3.2e14Initial program 75.7%
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-*.f6453.9
Applied rewrites53.9%
if 3.2e14 < b Initial program 77.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6455.2
Applied rewrites55.2%
Final simplification53.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -1.55e+62)
(* (* b a) i)
(if (<= a -6.8e-157)
(* (* (- i) j) y)
(if (<= a 2.35e+32) (* (* z y) x) (* (* i b) a)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -1.55e+62) {
tmp = (b * a) * i;
} else if (a <= -6.8e-157) {
tmp = (-i * j) * y;
} else if (a <= 2.35e+32) {
tmp = (z * y) * x;
} else {
tmp = (i * b) * a;
}
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 (a <= (-1.55d+62)) then
tmp = (b * a) * i
else if (a <= (-6.8d-157)) then
tmp = (-i * j) * y
else if (a <= 2.35d+32) then
tmp = (z * y) * x
else
tmp = (i * b) * a
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 (a <= -1.55e+62) {
tmp = (b * a) * i;
} else if (a <= -6.8e-157) {
tmp = (-i * j) * y;
} else if (a <= 2.35e+32) {
tmp = (z * y) * x;
} else {
tmp = (i * b) * a;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if a <= -1.55e+62: tmp = (b * a) * i elif a <= -6.8e-157: tmp = (-i * j) * y elif a <= 2.35e+32: tmp = (z * y) * x else: tmp = (i * b) * a return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -1.55e+62) tmp = Float64(Float64(b * a) * i); elseif (a <= -6.8e-157) tmp = Float64(Float64(Float64(-i) * j) * y); elseif (a <= 2.35e+32) tmp = Float64(Float64(z * y) * x); else tmp = Float64(Float64(i * b) * a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (a <= -1.55e+62) tmp = (b * a) * i; elseif (a <= -6.8e-157) tmp = (-i * j) * y; elseif (a <= 2.35e+32) tmp = (z * y) * x; else tmp = (i * b) * a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -1.55e+62], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[a, -6.8e-157], N[(N[((-i) * j), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[a, 2.35e+32], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.55 \cdot 10^{+62}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;a \leq -6.8 \cdot 10^{-157}:\\
\;\;\;\;\left(\left(-i\right) \cdot j\right) \cdot y\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+32}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\end{array}
\end{array}
if a < -1.55000000000000007e62Initial program 70.3%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6455.6
Applied rewrites55.6%
Taylor expanded in b around inf
Applied rewrites44.5%
if -1.55000000000000007e62 < a < -6.79999999999999955e-157Initial program 76.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-*.f6451.2
Applied rewrites51.2%
Taylor expanded in b around 0
Applied rewrites40.6%
if -6.79999999999999955e-157 < a < 2.35000000000000012e32Initial program 79.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-*.f6439.1
Applied rewrites39.1%
Taylor expanded in a around 0
Applied rewrites33.5%
if 2.35000000000000012e32 < a Initial program 72.2%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites74.5%
Taylor expanded in i around inf
Applied rewrites53.1%
Final simplification41.0%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= a -21000000.0) (* (* b a) i) (if (<= a 2.35e+32) (* (* z y) x) (* (* i b) a))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -21000000.0) {
tmp = (b * a) * i;
} else if (a <= 2.35e+32) {
tmp = (z * y) * x;
} else {
tmp = (i * b) * a;
}
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 (a <= (-21000000.0d0)) then
tmp = (b * a) * i
else if (a <= 2.35d+32) then
tmp = (z * y) * x
else
tmp = (i * b) * a
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 (a <= -21000000.0) {
tmp = (b * a) * i;
} else if (a <= 2.35e+32) {
tmp = (z * y) * x;
} else {
tmp = (i * b) * a;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if a <= -21000000.0: tmp = (b * a) * i elif a <= 2.35e+32: tmp = (z * y) * x else: tmp = (i * b) * a return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -21000000.0) tmp = Float64(Float64(b * a) * i); elseif (a <= 2.35e+32) tmp = Float64(Float64(z * y) * x); else tmp = Float64(Float64(i * b) * a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (a <= -21000000.0) tmp = (b * a) * i; elseif (a <= 2.35e+32) tmp = (z * y) * x; else tmp = (i * b) * a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -21000000.0], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[a, 2.35e+32], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -21000000:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+32}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\end{array}
\end{array}
if a < -2.1e7Initial program 71.5%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6459.7
Applied rewrites59.7%
Taylor expanded in b around inf
Applied rewrites42.3%
if -2.1e7 < a < 2.35000000000000012e32Initial program 78.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-*.f6437.9
Applied rewrites37.9%
Taylor expanded in a around 0
Applied rewrites30.8%
if 2.35000000000000012e32 < a Initial program 72.2%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites74.5%
Taylor expanded in i around inf
Applied rewrites53.1%
Final simplification38.3%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* i b) a))) (if (<= a -21000000.0) t_1 (if (<= a 2.35e+32) (* (* 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 = (i * b) * a;
double tmp;
if (a <= -21000000.0) {
tmp = t_1;
} else if (a <= 2.35e+32) {
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 = (i * b) * a
if (a <= (-21000000.0d0)) then
tmp = t_1
else if (a <= 2.35d+32) 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 = (i * b) * a;
double tmp;
if (a <= -21000000.0) {
tmp = t_1;
} else if (a <= 2.35e+32) {
tmp = (z * y) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * b) * a tmp = 0 if a <= -21000000.0: tmp = t_1 elif a <= 2.35e+32: 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(i * b) * a) tmp = 0.0 if (a <= -21000000.0) tmp = t_1; elseif (a <= 2.35e+32) 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 = (i * b) * a; tmp = 0.0; if (a <= -21000000.0) tmp = t_1; elseif (a <= 2.35e+32) 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[(i * b), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[a, -21000000.0], t$95$1, If[LessEqual[a, 2.35e+32], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot a\\
\mathbf{if}\;a \leq -21000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+32}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -2.1e7 or 2.35000000000000012e32 < a Initial program 71.8%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites72.1%
Taylor expanded in i around inf
Applied rewrites46.0%
if -2.1e7 < a < 2.35000000000000012e32Initial program 78.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-*.f6437.9
Applied rewrites37.9%
Taylor expanded in a around 0
Applied rewrites30.8%
Final simplification38.0%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* i b) a))) (if (<= i -3.15e-15) t_1 (if (<= i 1.25e-79) (* (* j t) c) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * b) * a;
double tmp;
if (i <= -3.15e-15) {
tmp = t_1;
} else if (i <= 1.25e-79) {
tmp = (j * t) * c;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (i * b) * a
if (i <= (-3.15d-15)) then
tmp = t_1
else if (i <= 1.25d-79) then
tmp = (j * t) * c
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * b) * a;
double tmp;
if (i <= -3.15e-15) {
tmp = t_1;
} else if (i <= 1.25e-79) {
tmp = (j * t) * c;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * b) * a tmp = 0 if i <= -3.15e-15: tmp = t_1 elif i <= 1.25e-79: tmp = (j * t) * c else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * b) * a) tmp = 0.0 if (i <= -3.15e-15) tmp = t_1; elseif (i <= 1.25e-79) tmp = Float64(Float64(j * t) * c); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (i * b) * a; tmp = 0.0; if (i <= -3.15e-15) tmp = t_1; elseif (i <= 1.25e-79) tmp = (j * t) * c; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[i, -3.15e-15], t$95$1, If[LessEqual[i, 1.25e-79], N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot a\\
\mathbf{if}\;i \leq -3.15 \cdot 10^{-15}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 1.25 \cdot 10^{-79}:\\
\;\;\;\;\left(j \cdot t\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -3.14999999999999991e-15 or 1.25e-79 < i Initial program 72.1%
Taylor expanded in j around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
remove-double-negN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites66.5%
Taylor expanded in i around inf
Applied rewrites41.0%
if -3.14999999999999991e-15 < i < 1.25e-79Initial program 80.5%
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-*.f6434.0
Applied rewrites34.0%
Taylor expanded in c around inf
Applied rewrites26.0%
Final simplification34.8%
(FPCore (x y z t a b c i j) :precision binary64 (* (* j c) t))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (j * c) * t;
}
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 = (j * c) * t
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 (j * c) * t;
}
def code(x, y, z, t, a, b, c, i, j): return (j * c) * t
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(j * c) * t) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (j * c) * t; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision]
\begin{array}{l}
\\
\left(j \cdot c\right) \cdot t
\end{array}
Initial program 75.6%
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-*.f6435.5
Applied rewrites35.5%
Taylor expanded in c around inf
Applied rewrites18.4%
Applied rewrites18.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024243
(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)))))