
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 26 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(-
(* (- (* c a) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i t) (* c z)) b)))))
(if (<= t_1 INFINITY)
t_1
(* (fma j a (/ (fma (- a) (* t x) (* (fma (- i) j (* z x)) y)) c)) 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 * a) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * t) - (c * z)) * b));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(j, a, (fma(-a, (t * x), (fma(-i, j, (z * x)) * y)) / c)) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(Float64(c * a) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * t) - Float64(c * z)) * b))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(fma(j, a, Float64(fma(Float64(-a), Float64(t * x), Float64(fma(Float64(-i), j, Float64(z * x)) * y)) / c)) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(N[(c * a), $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 * t), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[(j * a + N[(N[((-a) * N[(t * x), $MachinePrecision] + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot a - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot t - c \cdot z\right) \cdot b\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(j, a, \frac{\mathsf{fma}\left(-a, t \cdot x, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)}{c}\right) \cdot c\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) < +inf.0Initial program 92.7%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) Initial program 0.0%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f640.0
Applied rewrites0.0%
Taylor expanded in b around 0
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-fma.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
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.0%
Taylor expanded in c around -inf
Applied rewrites66.0%
Final simplification88.4%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<=
(-
(* (- (* c a) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i t) (* c z)) b)))
INFINITY)
(- (- (* (- (* z y) (* a t)) x) (* (* c b) z)) (* (- (* i y) (* c a)) j))
(* (fma j a (/ (fma (- a) (* t x) (* (fma (- i) j (* z x)) y)) c)) c)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (((((c * a) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * t) - (c * z)) * b))) <= ((double) INFINITY)) {
tmp = ((((z * y) - (a * t)) * x) - ((c * b) * z)) - (((i * y) - (c * a)) * j);
} else {
tmp = fma(j, a, (fma(-a, (t * x), (fma(-i, j, (z * x)) * y)) / c)) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (Float64(Float64(Float64(Float64(c * a) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * t) - Float64(c * z)) * b))) <= Inf) tmp = Float64(Float64(Float64(Float64(Float64(z * y) - Float64(a * t)) * x) - Float64(Float64(c * b) * z)) - Float64(Float64(Float64(i * y) - Float64(c * a)) * j)); else tmp = Float64(fma(j, a, Float64(fma(Float64(-a), Float64(t * x), Float64(fma(Float64(-i), j, Float64(z * x)) * y)) / c)) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[N[(N[(N[(N[(c * a), $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 * t), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(N[(N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(c * b), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(i * y), $MachinePrecision] - N[(c * a), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], N[(N[(j * a + N[(N[((-a) * N[(t * x), $MachinePrecision] + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(c \cdot a - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot t - c \cdot z\right) \cdot b\right) \leq \infty:\\
\;\;\;\;\left(\left(z \cdot y - a \cdot t\right) \cdot x - \left(c \cdot b\right) \cdot z\right) - \left(i \cdot y - c \cdot a\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(j, a, \frac{\mathsf{fma}\left(-a, t \cdot x, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)}{c}\right) \cdot c\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) < +inf.0Initial program 92.7%
Taylor expanded in z around inf
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6479.9
Applied rewrites79.9%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) Initial program 0.0%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f640.0
Applied rewrites0.0%
Taylor expanded in b around 0
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-fma.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
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.0%
Taylor expanded in c around -inf
Applied rewrites66.0%
Final simplification77.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) b (* y x)) z)))
(if (<= z -1.9e+177)
t_1
(if (<= z -1.9e+76)
(* (* (- a (/ (* b z) j)) c) j)
(if (<= z -4.2e-125)
(* (fma (- z) c (* i t)) b)
(if (<= z 5e-305)
(* (fma (- y) j (* b t)) i)
(if (<= z 1.9e-80)
(* (fma (- x) a (* i b)) t)
(if (<= z 5e+134) (* (fma (- z) x (* j i)) (- 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, b, (y * x)) * z;
double tmp;
if (z <= -1.9e+177) {
tmp = t_1;
} else if (z <= -1.9e+76) {
tmp = ((a - ((b * z) / j)) * c) * j;
} else if (z <= -4.2e-125) {
tmp = fma(-z, c, (i * t)) * b;
} else if (z <= 5e-305) {
tmp = fma(-y, j, (b * t)) * i;
} else if (z <= 1.9e-80) {
tmp = fma(-x, a, (i * b)) * t;
} else if (z <= 5e+134) {
tmp = fma(-z, x, (j * i)) * -y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), b, Float64(y * x)) * z) tmp = 0.0 if (z <= -1.9e+177) tmp = t_1; elseif (z <= -1.9e+76) tmp = Float64(Float64(Float64(a - Float64(Float64(b * z) / j)) * c) * j); elseif (z <= -4.2e-125) tmp = Float64(fma(Float64(-z), c, Float64(i * t)) * b); elseif (z <= 5e-305) tmp = Float64(fma(Float64(-y), j, Float64(b * t)) * i); elseif (z <= 1.9e-80) tmp = Float64(fma(Float64(-x), a, Float64(i * b)) * t); elseif (z <= 5e+134) tmp = Float64(fma(Float64(-z), x, Float64(j * i)) * Float64(-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) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -1.9e+177], t$95$1, If[LessEqual[z, -1.9e+76], N[(N[(N[(a - N[(N[(b * z), $MachinePrecision] / j), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[z, -4.2e-125], N[(N[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[z, 5e-305], N[(N[((-y) * j + N[(b * t), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[z, 1.9e-80], N[(N[((-x) * a + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, 5e+134], N[(N[((-z) * x + N[(j * i), $MachinePrecision]), $MachinePrecision] * (-y)), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -1.9 \cdot 10^{+177}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.9 \cdot 10^{+76}:\\
\;\;\;\;\left(\left(a - \frac{b \cdot z}{j}\right) \cdot c\right) \cdot j\\
\mathbf{elif}\;z \leq -4.2 \cdot 10^{-125}:\\
\;\;\;\;\mathsf{fma}\left(-z, c, i \cdot t\right) \cdot b\\
\mathbf{elif}\;z \leq 5 \cdot 10^{-305}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot t\right) \cdot i\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{-80}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, i \cdot b\right) \cdot t\\
\mathbf{elif}\;z \leq 5 \cdot 10^{+134}:\\
\;\;\;\;\mathsf{fma}\left(-z, x, j \cdot i\right) \cdot \left(-y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.8999999999999999e177 or 4.99999999999999981e134 < z Initial program 61.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6479.1
Applied rewrites79.1%
if -1.8999999999999999e177 < z < -1.90000000000000012e76Initial program 78.3%
Taylor expanded in j around -inf
Applied rewrites73.4%
Taylor expanded in c around inf
Applied rewrites79.3%
if -1.90000000000000012e76 < z < -4.2e-125Initial program 82.4%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6457.4
Applied rewrites57.4%
if -4.2e-125 < z < 4.99999999999999985e-305Initial program 79.6%
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
lower-*.f6463.3
Applied rewrites63.3%
if 4.99999999999999985e-305 < z < 1.89999999999999983e-80Initial program 82.0%
Taylor expanded in t 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.8
Applied rewrites60.8%
if 1.89999999999999983e-80 < z < 4.99999999999999981e134Initial program 87.5%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6487.5
Applied rewrites87.5%
Taylor expanded in y around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/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
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6461.9
Applied rewrites61.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) b (* y x)) z)))
(if (<= z -3.4e+121)
t_1
(if (<= z -1.3e+43)
(* (fma (- x) t (* j c)) a)
(if (<= z -4.2e-125)
(* (fma (- z) c (* i t)) b)
(if (<= z 5e-305)
(* (fma (- y) j (* b t)) i)
(if (<= z 1.9e-80)
(* (fma (- x) a (* i b)) t)
(if (<= z 5e+134) (* (fma (- z) x (* j i)) (- 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, b, (y * x)) * z;
double tmp;
if (z <= -3.4e+121) {
tmp = t_1;
} else if (z <= -1.3e+43) {
tmp = fma(-x, t, (j * c)) * a;
} else if (z <= -4.2e-125) {
tmp = fma(-z, c, (i * t)) * b;
} else if (z <= 5e-305) {
tmp = fma(-y, j, (b * t)) * i;
} else if (z <= 1.9e-80) {
tmp = fma(-x, a, (i * b)) * t;
} else if (z <= 5e+134) {
tmp = fma(-z, x, (j * i)) * -y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), b, Float64(y * x)) * z) tmp = 0.0 if (z <= -3.4e+121) tmp = t_1; elseif (z <= -1.3e+43) tmp = Float64(fma(Float64(-x), t, Float64(j * c)) * a); elseif (z <= -4.2e-125) tmp = Float64(fma(Float64(-z), c, Float64(i * t)) * b); elseif (z <= 5e-305) tmp = Float64(fma(Float64(-y), j, Float64(b * t)) * i); elseif (z <= 1.9e-80) tmp = Float64(fma(Float64(-x), a, Float64(i * b)) * t); elseif (z <= 5e+134) tmp = Float64(fma(Float64(-z), x, Float64(j * i)) * Float64(-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) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -3.4e+121], t$95$1, If[LessEqual[z, -1.3e+43], N[(N[((-x) * t + N[(j * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[z, -4.2e-125], N[(N[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[z, 5e-305], N[(N[((-y) * j + N[(b * t), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[z, 1.9e-80], N[(N[((-x) * a + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, 5e+134], N[(N[((-z) * x + N[(j * i), $MachinePrecision]), $MachinePrecision] * (-y)), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -3.4 \cdot 10^{+121}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{+43}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, j \cdot c\right) \cdot a\\
\mathbf{elif}\;z \leq -4.2 \cdot 10^{-125}:\\
\;\;\;\;\mathsf{fma}\left(-z, c, i \cdot t\right) \cdot b\\
\mathbf{elif}\;z \leq 5 \cdot 10^{-305}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot t\right) \cdot i\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{-80}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, i \cdot b\right) \cdot t\\
\mathbf{elif}\;z \leq 5 \cdot 10^{+134}:\\
\;\;\;\;\mathsf{fma}\left(-z, x, j \cdot i\right) \cdot \left(-y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.4000000000000001e121 or 4.99999999999999981e134 < z Initial program 62.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.4
Applied rewrites76.4%
if -3.4000000000000001e121 < z < -1.3000000000000001e43Initial program 79.9%
Taylor expanded in a 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.7
Applied rewrites60.7%
if -1.3000000000000001e43 < z < -4.2e-125Initial program 85.4%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6463.8
Applied rewrites63.8%
if -4.2e-125 < z < 4.99999999999999985e-305Initial program 79.6%
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
lower-*.f6463.3
Applied rewrites63.3%
if 4.99999999999999985e-305 < z < 1.89999999999999983e-80Initial program 82.0%
Taylor expanded in t 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.8
Applied rewrites60.8%
if 1.89999999999999983e-80 < z < 4.99999999999999981e134Initial program 87.5%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6487.5
Applied rewrites87.5%
Taylor expanded in y around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/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
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6461.9
Applied rewrites61.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) b (* y x)) z)))
(if (<= z -1.9e+177)
t_1
(if (<= z -3.8e+74)
(* (* (- a (/ (* b z) j)) c) j)
(if (<= z 1.02e+144)
(fma (fma (- y) j (* b t)) i (* (fma (- t) a (* 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, b, (y * x)) * z;
double tmp;
if (z <= -1.9e+177) {
tmp = t_1;
} else if (z <= -3.8e+74) {
tmp = ((a - ((b * z) / j)) * c) * j;
} else if (z <= 1.02e+144) {
tmp = fma(fma(-y, j, (b * t)), i, (fma(-t, a, (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), b, Float64(y * x)) * z) tmp = 0.0 if (z <= -1.9e+177) tmp = t_1; elseif (z <= -3.8e+74) tmp = Float64(Float64(Float64(a - Float64(Float64(b * z) / j)) * c) * j); elseif (z <= 1.02e+144) tmp = fma(fma(Float64(-y), j, Float64(b * t)), i, Float64(fma(Float64(-t), a, 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 + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -1.9e+177], t$95$1, If[LessEqual[z, -3.8e+74], N[(N[(N[(a - N[(N[(b * z), $MachinePrecision] / j), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[z, 1.02e+144], N[(N[((-y) * j + N[(b * t), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -1.9 \cdot 10^{+177}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{+74}:\\
\;\;\;\;\left(\left(a - \frac{b \cdot z}{j}\right) \cdot c\right) \cdot j\\
\mathbf{elif}\;z \leq 1.02 \cdot 10^{+144}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot t\right), i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.8999999999999999e177 or 1.02000000000000008e144 < z Initial program 61.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6481.9
Applied rewrites81.9%
if -1.8999999999999999e177 < z < -3.7999999999999998e74Initial program 79.3%
Taylor expanded in j around -inf
Applied rewrites74.7%
Taylor expanded in c around inf
Applied rewrites75.6%
if -3.7999999999999998e74 < z < 1.02000000000000008e144Initial program 82.5%
Taylor expanded in c around 0
cancel-sign-sub-invN/A
+-commutativeN/A
metadata-evalN/A
*-lft-identityN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites69.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) b (* y x)) z)))
(if (<= z -3.4e+121)
t_1
(if (<= z -1.3e+43)
(* (fma (- x) t (* j c)) a)
(if (<= z -4.2e-125)
(* (fma (- z) c (* i t)) b)
(if (<= z 5e-305)
(* (fma (- y) j (* b t)) i)
(if (<= z 1.9e-80)
(* (fma (- x) a (* i b)) t)
(if (<= z 4.1e+90) (* (fma (- i) j (* z x)) y) t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-c, b, (y * x)) * z;
double tmp;
if (z <= -3.4e+121) {
tmp = t_1;
} else if (z <= -1.3e+43) {
tmp = fma(-x, t, (j * c)) * a;
} else if (z <= -4.2e-125) {
tmp = fma(-z, c, (i * t)) * b;
} else if (z <= 5e-305) {
tmp = fma(-y, j, (b * t)) * i;
} else if (z <= 1.9e-80) {
tmp = fma(-x, a, (i * b)) * t;
} else if (z <= 4.1e+90) {
tmp = fma(-i, j, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), b, Float64(y * x)) * z) tmp = 0.0 if (z <= -3.4e+121) tmp = t_1; elseif (z <= -1.3e+43) tmp = Float64(fma(Float64(-x), t, Float64(j * c)) * a); elseif (z <= -4.2e-125) tmp = Float64(fma(Float64(-z), c, Float64(i * t)) * b); elseif (z <= 5e-305) tmp = Float64(fma(Float64(-y), j, Float64(b * t)) * i); elseif (z <= 1.9e-80) tmp = Float64(fma(Float64(-x), a, Float64(i * b)) * t); elseif (z <= 4.1e+90) tmp = Float64(fma(Float64(-i), j, Float64(z * x)) * y); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -3.4e+121], t$95$1, If[LessEqual[z, -1.3e+43], N[(N[((-x) * t + N[(j * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[z, -4.2e-125], N[(N[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[z, 5e-305], N[(N[((-y) * j + N[(b * t), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[z, 1.9e-80], N[(N[((-x) * a + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, 4.1e+90], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -3.4 \cdot 10^{+121}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{+43}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, j \cdot c\right) \cdot a\\
\mathbf{elif}\;z \leq -4.2 \cdot 10^{-125}:\\
\;\;\;\;\mathsf{fma}\left(-z, c, i \cdot t\right) \cdot b\\
\mathbf{elif}\;z \leq 5 \cdot 10^{-305}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot t\right) \cdot i\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{-80}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, i \cdot b\right) \cdot t\\
\mathbf{elif}\;z \leq 4.1 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.4000000000000001e121 or 4.10000000000000042e90 < z Initial program 65.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.3
Applied rewrites74.3%
if -3.4000000000000001e121 < z < -1.3000000000000001e43Initial program 79.9%
Taylor expanded in a 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.7
Applied rewrites60.7%
if -1.3000000000000001e43 < z < -4.2e-125Initial program 85.4%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6463.8
Applied rewrites63.8%
if -4.2e-125 < z < 4.99999999999999985e-305Initial program 79.6%
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
lower-*.f6463.3
Applied rewrites63.3%
if 4.99999999999999985e-305 < z < 1.89999999999999983e-80Initial program 82.0%
Taylor expanded in t 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.8
Applied rewrites60.8%
if 1.89999999999999983e-80 < z < 4.10000000000000042e90Initial program 91.2%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.8
Applied rewrites60.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (- i) (* j y) (fma (fma (- t) a (* z y)) x (* (* j c) a)))))
(if (<= x -3.8e+46)
t_1
(if (<= x 1450000000000.0)
(fma (fma (- z) c (* i t)) b (* (fma (- i) j (* z x)) y))
t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-i, (j * y), fma(fma(-t, a, (z * y)), x, ((j * c) * a)));
double tmp;
if (x <= -3.8e+46) {
tmp = t_1;
} else if (x <= 1450000000000.0) {
tmp = fma(fma(-z, c, (i * t)), b, (fma(-i, j, (z * x)) * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(-i), Float64(j * y), fma(fma(Float64(-t), a, Float64(z * y)), x, Float64(Float64(j * c) * a))) tmp = 0.0 if (x <= -3.8e+46) tmp = t_1; elseif (x <= 1450000000000.0) tmp = fma(fma(Float64(-z), c, Float64(i * t)), b, Float64(fma(Float64(-i), j, Float64(z * x)) * y)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-i) * N[(j * y), $MachinePrecision] + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x + N[(N[(j * c), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.8e+46], t$95$1, If[LessEqual[x, 1450000000000.0], N[(N[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, j \cdot y, \mathsf{fma}\left(\mathsf{fma}\left(-t, a, z \cdot y\right), x, \left(j \cdot c\right) \cdot a\right)\right)\\
\mathbf{if}\;x \leq -3.8 \cdot 10^{+46}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1450000000000:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, c, i \cdot t\right), b, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.7999999999999999e46 or 1.45e12 < x Initial program 81.2%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6480.3
Applied rewrites80.3%
Taylor expanded in b around 0
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-fma.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
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites82.9%
if -3.7999999999999999e46 < x < 1.45e12Initial program 75.4%
Taylor expanded in a 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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites75.9%
Final simplification78.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- y) j (* b t)) i (* (fma (- t) a (* z y)) x))))
(if (<= x -3.5e+46)
t_1
(if (<= x 5e+150)
(fma (fma (- z) c (* i t)) b (* (fma (- i) j (* z x)) y))
t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(fma(-y, j, (b * t)), i, (fma(-t, a, (z * y)) * x));
double tmp;
if (x <= -3.5e+46) {
tmp = t_1;
} else if (x <= 5e+150) {
tmp = fma(fma(-z, c, (i * t)), b, (fma(-i, j, (z * x)) * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-y), j, Float64(b * t)), i, Float64(fma(Float64(-t), a, Float64(z * y)) * x)) tmp = 0.0 if (x <= -3.5e+46) tmp = t_1; elseif (x <= 5e+150) tmp = fma(fma(Float64(-z), c, Float64(i * t)), b, Float64(fma(Float64(-i), j, Float64(z * x)) * y)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-y) * j + N[(b * t), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.5e+46], t$95$1, If[LessEqual[x, 5e+150], N[(N[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot t\right), i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\mathbf{if}\;x \leq -3.5 \cdot 10^{+46}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 5 \cdot 10^{+150}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, c, i \cdot t\right), b, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.49999999999999985e46 or 5.00000000000000009e150 < x Initial program 79.9%
Taylor expanded in c around 0
cancel-sign-sub-invN/A
+-commutativeN/A
metadata-evalN/A
*-lft-identityN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites82.7%
if -3.49999999999999985e46 < x < 5.00000000000000009e150Initial program 76.8%
Taylor expanded in a 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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites75.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) b (* y x)) z)))
(if (<= z -3.4e+121)
t_1
(if (<= z -3.85e-62)
(* (fma (- x) t (* j c)) a)
(if (<= z 5e-305)
(* (fma (- y) j (* b t)) i)
(if (<= z 1.9e-80)
(* (fma (- x) a (* i b)) t)
(if (<= z 4.1e+90) (* (fma (- i) j (* z x)) y) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-c, b, (y * x)) * z;
double tmp;
if (z <= -3.4e+121) {
tmp = t_1;
} else if (z <= -3.85e-62) {
tmp = fma(-x, t, (j * c)) * a;
} else if (z <= 5e-305) {
tmp = fma(-y, j, (b * t)) * i;
} else if (z <= 1.9e-80) {
tmp = fma(-x, a, (i * b)) * t;
} else if (z <= 4.1e+90) {
tmp = fma(-i, j, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), b, Float64(y * x)) * z) tmp = 0.0 if (z <= -3.4e+121) tmp = t_1; elseif (z <= -3.85e-62) tmp = Float64(fma(Float64(-x), t, Float64(j * c)) * a); elseif (z <= 5e-305) tmp = Float64(fma(Float64(-y), j, Float64(b * t)) * i); elseif (z <= 1.9e-80) tmp = Float64(fma(Float64(-x), a, Float64(i * b)) * t); elseif (z <= 4.1e+90) tmp = Float64(fma(Float64(-i), j, Float64(z * x)) * y); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -3.4e+121], t$95$1, If[LessEqual[z, -3.85e-62], N[(N[((-x) * t + N[(j * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[z, 5e-305], N[(N[((-y) * j + N[(b * t), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[z, 1.9e-80], N[(N[((-x) * a + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, 4.1e+90], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -3.4 \cdot 10^{+121}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -3.85 \cdot 10^{-62}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, j \cdot c\right) \cdot a\\
\mathbf{elif}\;z \leq 5 \cdot 10^{-305}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot t\right) \cdot i\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{-80}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, i \cdot b\right) \cdot t\\
\mathbf{elif}\;z \leq 4.1 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.4000000000000001e121 or 4.10000000000000042e90 < z Initial program 65.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.3
Applied rewrites74.3%
if -3.4000000000000001e121 < z < -3.84999999999999998e-62Initial program 82.6%
Taylor expanded in a 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-*.f6448.4
Applied rewrites48.4%
if -3.84999999999999998e-62 < z < 4.99999999999999985e-305Initial program 81.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
lower-*.f6461.9
Applied rewrites61.9%
if 4.99999999999999985e-305 < z < 1.89999999999999983e-80Initial program 82.0%
Taylor expanded in t 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.8
Applied rewrites60.8%
if 1.89999999999999983e-80 < z < 4.10000000000000042e90Initial program 91.2%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.8
Applied rewrites60.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -1.12e+126)
(* (fma (- x) t (* j c)) a)
(if (<= a 7.8e+14)
(fma (* i t) b (* (fma (- i) j (* z x)) y))
(* (fma (- a) (/ (* j c) t) (* a x)) (- t)))))
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.12e+126) {
tmp = fma(-x, t, (j * c)) * a;
} else if (a <= 7.8e+14) {
tmp = fma((i * t), b, (fma(-i, j, (z * x)) * y));
} else {
tmp = fma(-a, ((j * c) / t), (a * x)) * -t;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -1.12e+126) tmp = Float64(fma(Float64(-x), t, Float64(j * c)) * a); elseif (a <= 7.8e+14) tmp = fma(Float64(i * t), b, Float64(fma(Float64(-i), j, Float64(z * x)) * y)); else tmp = Float64(fma(Float64(-a), Float64(Float64(j * c) / t), Float64(a * x)) * Float64(-t)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -1.12e+126], N[(N[((-x) * t + N[(j * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[a, 7.8e+14], N[(N[(i * t), $MachinePrecision] * b + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], N[(N[((-a) * N[(N[(j * c), $MachinePrecision] / t), $MachinePrecision] + N[(a * x), $MachinePrecision]), $MachinePrecision] * (-t)), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.12 \cdot 10^{+126}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, j \cdot c\right) \cdot a\\
\mathbf{elif}\;a \leq 7.8 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(i \cdot t, b, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-a, \frac{j \cdot c}{t}, a \cdot x\right) \cdot \left(-t\right)\\
\end{array}
\end{array}
if a < -1.12e126Initial program 64.9%
Taylor expanded in a 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-*.f6465.5
Applied rewrites65.5%
if -1.12e126 < a < 7.8e14Initial program 83.0%
Taylor expanded in a 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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites78.7%
Taylor expanded in z around 0
Applied rewrites64.6%
if 7.8e14 < a Initial program 69.6%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6469.6
Applied rewrites69.6%
Taylor expanded in a around inf
*-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-*.f6463.7
Applied rewrites63.7%
Taylor expanded in t around -inf
Applied rewrites67.3%
Final simplification65.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i t)) b)))
(if (<= b -9e+113)
t_1
(if (<= b 5.1e-73) (+ (* (* z x) y) (* (- (* c a) (* 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(-z, c, (i * t)) * b;
double tmp;
if (b <= -9e+113) {
tmp = t_1;
} else if (b <= 5.1e-73) {
tmp = ((z * x) * y) + (((c * a) - (i * y)) * j);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * t)) * b) tmp = 0.0 if (b <= -9e+113) tmp = t_1; elseif (b <= 5.1e-73) tmp = Float64(Float64(Float64(z * x) * y) + Float64(Float64(Float64(c * a) - 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[((-z) * c + N[(i * t), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -9e+113], t$95$1, If[LessEqual[b, 5.1e-73], N[(N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision] + N[(N[(N[(c * a), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot t\right) \cdot b\\
\mathbf{if}\;b \leq -9 \cdot 10^{+113}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 5.1 \cdot 10^{-73}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y + \left(c \cdot a - i \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -9.0000000000000001e113 or 5.1e-73 < b Initial program 83.1%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6468.6
Applied rewrites68.6%
if -9.0000000000000001e113 < b < 5.1e-73Initial program 73.7%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6461.7
Applied rewrites61.7%
Final simplification64.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) t (* j c)) a)))
(if (<= a -1.12e+126)
t_1
(if (<= a 7.8e+14) (fma (* i t) b (* (fma (- i) j (* z x)) y)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-x, t, (j * c)) * a;
double tmp;
if (a <= -1.12e+126) {
tmp = t_1;
} else if (a <= 7.8e+14) {
tmp = fma((i * t), b, (fma(-i, j, (z * x)) * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), t, Float64(j * c)) * a) tmp = 0.0 if (a <= -1.12e+126) tmp = t_1; elseif (a <= 7.8e+14) tmp = fma(Float64(i * t), b, Float64(fma(Float64(-i), j, Float64(z * x)) * y)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * t + N[(j * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[a, -1.12e+126], t$95$1, If[LessEqual[a, 7.8e+14], N[(N[(i * t), $MachinePrecision] * b + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, t, j \cdot c\right) \cdot a\\
\mathbf{if}\;a \leq -1.12 \cdot 10^{+126}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 7.8 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(i \cdot t, b, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -1.12e126 or 7.8e14 < a Initial program 67.9%
Taylor expanded in a 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-*.f6464.3
Applied rewrites64.3%
if -1.12e126 < a < 7.8e14Initial program 83.0%
Taylor expanded in a 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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites78.7%
Taylor expanded in z around 0
Applied rewrites64.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* i b) t)))
(if (<= i -1.7e+170)
t_1
(if (<= i -1.55e-27)
(* (* (- j) y) i)
(if (<= i 3.3e-242)
(* (* (- z) c) b)
(if (<= i 1.42e-89) (* (* (- x) a) 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 = (i * b) * t;
double tmp;
if (i <= -1.7e+170) {
tmp = t_1;
} else if (i <= -1.55e-27) {
tmp = (-j * y) * i;
} else if (i <= 3.3e-242) {
tmp = (-z * c) * b;
} else if (i <= 1.42e-89) {
tmp = (-x * a) * 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 = (i * b) * t
if (i <= (-1.7d+170)) then
tmp = t_1
else if (i <= (-1.55d-27)) then
tmp = (-j * y) * i
else if (i <= 3.3d-242) then
tmp = (-z * c) * b
else if (i <= 1.42d-89) then
tmp = (-x * a) * 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 = (i * b) * t;
double tmp;
if (i <= -1.7e+170) {
tmp = t_1;
} else if (i <= -1.55e-27) {
tmp = (-j * y) * i;
} else if (i <= 3.3e-242) {
tmp = (-z * c) * b;
} else if (i <= 1.42e-89) {
tmp = (-x * a) * t;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * b) * t tmp = 0 if i <= -1.7e+170: tmp = t_1 elif i <= -1.55e-27: tmp = (-j * y) * i elif i <= 3.3e-242: tmp = (-z * c) * b elif i <= 1.42e-89: tmp = (-x * a) * t else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * b) * t) tmp = 0.0 if (i <= -1.7e+170) tmp = t_1; elseif (i <= -1.55e-27) tmp = Float64(Float64(Float64(-j) * y) * i); elseif (i <= 3.3e-242) tmp = Float64(Float64(Float64(-z) * c) * b); elseif (i <= 1.42e-89) tmp = Float64(Float64(Float64(-x) * a) * t); 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) * t; tmp = 0.0; if (i <= -1.7e+170) tmp = t_1; elseif (i <= -1.55e-27) tmp = (-j * y) * i; elseif (i <= 3.3e-242) tmp = (-z * c) * b; elseif (i <= 1.42e-89) tmp = (-x * a) * 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[(i * b), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[i, -1.7e+170], t$95$1, If[LessEqual[i, -1.55e-27], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[i, 3.3e-242], N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[i, 1.42e-89], N[(N[((-x) * a), $MachinePrecision] * t), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot t\\
\mathbf{if}\;i \leq -1.7 \cdot 10^{+170}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -1.55 \cdot 10^{-27}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{elif}\;i \leq 3.3 \cdot 10^{-242}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{elif}\;i \leq 1.42 \cdot 10^{-89}:\\
\;\;\;\;\left(\left(-x\right) \cdot a\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.7000000000000001e170 or 1.42e-89 < i Initial program 76.7%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6475.7
Applied rewrites75.7%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/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-*.f6449.5
Applied rewrites49.5%
Taylor expanded in x around 0
Applied rewrites43.3%
if -1.7000000000000001e170 < i < -1.5499999999999999e-27Initial program 72.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
lower-*.f6443.7
Applied rewrites43.7%
Taylor expanded in y around inf
Applied rewrites36.5%
if -1.5499999999999999e-27 < i < 3.29999999999999982e-242Initial program 82.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.9
Applied rewrites52.9%
Taylor expanded in x around 0
Applied rewrites38.8%
if 3.29999999999999982e-242 < i < 1.42e-89Initial program 78.0%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6478.0
Applied rewrites78.0%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/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-*.f6451.5
Applied rewrites51.5%
Taylor expanded in x around inf
Applied rewrites48.4%
Final simplification41.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) b (* y x)) z)))
(if (<= z -3.4e+121)
t_1
(if (<= z 1.9e-80)
(* (fma (- x) a (* i b)) t)
(if (<= z 4.1e+90) (* (fma (- i) j (* z x)) y) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-c, b, (y * x)) * z;
double tmp;
if (z <= -3.4e+121) {
tmp = t_1;
} else if (z <= 1.9e-80) {
tmp = fma(-x, a, (i * b)) * t;
} else if (z <= 4.1e+90) {
tmp = fma(-i, j, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), b, Float64(y * x)) * z) tmp = 0.0 if (z <= -3.4e+121) tmp = t_1; elseif (z <= 1.9e-80) tmp = Float64(fma(Float64(-x), a, Float64(i * b)) * t); elseif (z <= 4.1e+90) tmp = Float64(fma(Float64(-i), j, Float64(z * x)) * y); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -3.4e+121], t$95$1, If[LessEqual[z, 1.9e-80], N[(N[((-x) * a + N[(i * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[z, 4.1e+90], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -3.4 \cdot 10^{+121}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{-80}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, i \cdot b\right) \cdot t\\
\mathbf{elif}\;z \leq 4.1 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.4000000000000001e121 or 4.10000000000000042e90 < z Initial program 65.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.3
Applied rewrites74.3%
if -3.4000000000000001e121 < z < 1.89999999999999983e-80Initial program 81.7%
Taylor expanded in t 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.7
Applied rewrites51.7%
if 1.89999999999999983e-80 < z < 4.10000000000000042e90Initial program 91.2%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.8
Applied rewrites60.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- c) b (* y x)) z)))
(if (<= b -5.4e+119)
t_1
(if (<= b 5.1e-73)
(* (fma (- i) j (* z x)) y)
(if (<= b 7.2e+101) (* (* b t) 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(-c, b, (y * x)) * z;
double tmp;
if (b <= -5.4e+119) {
tmp = t_1;
} else if (b <= 5.1e-73) {
tmp = fma(-i, j, (z * x)) * y;
} else if (b <= 7.2e+101) {
tmp = (b * t) * i;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-c), b, Float64(y * x)) * z) tmp = 0.0 if (b <= -5.4e+119) tmp = t_1; elseif (b <= 5.1e-73) tmp = Float64(fma(Float64(-i), j, Float64(z * x)) * y); elseif (b <= 7.2e+101) tmp = Float64(Float64(b * t) * 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[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[b, -5.4e+119], t$95$1, If[LessEqual[b, 5.1e-73], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[b, 7.2e+101], N[(N[(b * t), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{if}\;b \leq -5.4 \cdot 10^{+119}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 5.1 \cdot 10^{-73}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{elif}\;b \leq 7.2 \cdot 10^{+101}:\\
\;\;\;\;\left(b \cdot t\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.3999999999999997e119 or 7.20000000000000058e101 < b Initial program 81.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6457.3
Applied rewrites57.3%
if -5.3999999999999997e119 < b < 5.1e-73Initial program 74.1%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.8
Applied rewrites49.8%
if 5.1e-73 < b < 7.20000000000000058e101Initial program 86.4%
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
lower-*.f6457.8
Applied rewrites57.8%
Taylor expanded in y around 0
Applied rewrites48.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* i b) t)))
(if (<= i -1.7e+170)
t_1
(if (<= i -9.2e+91)
(* (* (- j) y) i)
(if (<= i 4.8e+26) (* (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 = (i * b) * t;
double tmp;
if (i <= -1.7e+170) {
tmp = t_1;
} else if (i <= -9.2e+91) {
tmp = (-j * y) * i;
} else if (i <= 4.8e+26) {
tmp = 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(Float64(i * b) * t) tmp = 0.0 if (i <= -1.7e+170) tmp = t_1; elseif (i <= -9.2e+91) tmp = Float64(Float64(Float64(-j) * y) * i); elseif (i <= 4.8e+26) tmp = 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 * b), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[i, -1.7e+170], t$95$1, If[LessEqual[i, -9.2e+91], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[i, 4.8e+26], N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot t\\
\mathbf{if}\;i \leq -1.7 \cdot 10^{+170}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -9.2 \cdot 10^{+91}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{elif}\;i \leq 4.8 \cdot 10^{+26}:\\
\;\;\;\;\mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.7000000000000001e170 or 4.80000000000000009e26 < i Initial program 74.7%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6473.5
Applied rewrites73.5%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/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.0
Applied rewrites54.0%
Taylor expanded in x around 0
Applied rewrites47.8%
if -1.7000000000000001e170 < i < -9.19999999999999965e91Initial program 57.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
lower-*.f6457.5
Applied rewrites57.5%
Taylor expanded in y around inf
Applied rewrites57.5%
if -9.19999999999999965e91 < i < 4.80000000000000009e26Initial program 81.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.6
Applied rewrites49.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* i b) t)))
(if (<= i -1.7e+170)
t_1
(if (<= i -1.55e-27)
(* (* (- j) y) i)
(if (<= i 6.9e-279)
(* (* (- z) c) b)
(if (<= i 8.2e-60) (* (* 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) * t;
double tmp;
if (i <= -1.7e+170) {
tmp = t_1;
} else if (i <= -1.55e-27) {
tmp = (-j * y) * i;
} else if (i <= 6.9e-279) {
tmp = (-z * c) * b;
} else if (i <= 8.2e-60) {
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) * t
if (i <= (-1.7d+170)) then
tmp = t_1
else if (i <= (-1.55d-27)) then
tmp = (-j * y) * i
else if (i <= 6.9d-279) then
tmp = (-z * c) * b
else if (i <= 8.2d-60) 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) * t;
double tmp;
if (i <= -1.7e+170) {
tmp = t_1;
} else if (i <= -1.55e-27) {
tmp = (-j * y) * i;
} else if (i <= 6.9e-279) {
tmp = (-z * c) * b;
} else if (i <= 8.2e-60) {
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) * t tmp = 0 if i <= -1.7e+170: tmp = t_1 elif i <= -1.55e-27: tmp = (-j * y) * i elif i <= 6.9e-279: tmp = (-z * c) * b elif i <= 8.2e-60: 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) * t) tmp = 0.0 if (i <= -1.7e+170) tmp = t_1; elseif (i <= -1.55e-27) tmp = Float64(Float64(Float64(-j) * y) * i); elseif (i <= 6.9e-279) tmp = Float64(Float64(Float64(-z) * c) * b); elseif (i <= 8.2e-60) 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) * t; tmp = 0.0; if (i <= -1.7e+170) tmp = t_1; elseif (i <= -1.55e-27) tmp = (-j * y) * i; elseif (i <= 6.9e-279) tmp = (-z * c) * b; elseif (i <= 8.2e-60) 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] * t), $MachinePrecision]}, If[LessEqual[i, -1.7e+170], t$95$1, If[LessEqual[i, -1.55e-27], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[i, 6.9e-279], N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[i, 8.2e-60], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot t\\
\mathbf{if}\;i \leq -1.7 \cdot 10^{+170}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -1.55 \cdot 10^{-27}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{elif}\;i \leq 6.9 \cdot 10^{-279}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{elif}\;i \leq 8.2 \cdot 10^{-60}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.7000000000000001e170 or 8.20000000000000025e-60 < i Initial program 76.3%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6475.2
Applied rewrites75.2%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/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-*.f6451.5
Applied rewrites51.5%
Taylor expanded in x around 0
Applied rewrites45.0%
if -1.7000000000000001e170 < i < -1.5499999999999999e-27Initial program 72.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
lower-*.f6443.7
Applied rewrites43.7%
Taylor expanded in y around inf
Applied rewrites36.5%
if -1.5499999999999999e-27 < i < 6.90000000000000024e-279Initial program 81.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.9
Applied rewrites51.9%
Taylor expanded in x around 0
Applied rewrites40.4%
if 6.90000000000000024e-279 < i < 8.20000000000000025e-60Initial program 79.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.0
Applied rewrites52.0%
Taylor expanded in x around inf
Applied rewrites37.8%
Final simplification40.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) y (* c a)) j)))
(if (<= j -120000000.0)
t_1
(if (<= j 7e-90) (* (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 * a)) * j;
double tmp;
if (j <= -120000000.0) {
tmp = t_1;
} else if (j <= 7e-90) {
tmp = 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 * a)) * j) tmp = 0.0 if (j <= -120000000.0) tmp = t_1; elseif (j <= 7e-90) tmp = 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 * a), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -120000000.0], t$95$1, If[LessEqual[j, 7e-90], N[(N[((-c) * b + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, y, c \cdot a\right) \cdot j\\
\mathbf{if}\;j \leq -120000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 7 \cdot 10^{-90}:\\
\;\;\;\;\mathsf{fma}\left(-c, b, y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.2e8 or 6.9999999999999997e-90 < j Initial program 77.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6432.7
Applied rewrites32.7%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6463.2
Applied rewrites63.2%
if -1.2e8 < j < 6.9999999999999997e-90Initial program 78.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.1
Applied rewrites47.1%
Final simplification55.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* i b) t)))
(if (<= i -1.7e+170)
t_1
(if (<= i -6.7e-234)
(* (* (- b) z) c)
(if (<= i 8.2e-60) (* (* 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) * t;
double tmp;
if (i <= -1.7e+170) {
tmp = t_1;
} else if (i <= -6.7e-234) {
tmp = (-b * z) * c;
} else if (i <= 8.2e-60) {
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) * t
if (i <= (-1.7d+170)) then
tmp = t_1
else if (i <= (-6.7d-234)) then
tmp = (-b * z) * c
else if (i <= 8.2d-60) 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) * t;
double tmp;
if (i <= -1.7e+170) {
tmp = t_1;
} else if (i <= -6.7e-234) {
tmp = (-b * z) * c;
} else if (i <= 8.2e-60) {
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) * t tmp = 0 if i <= -1.7e+170: tmp = t_1 elif i <= -6.7e-234: tmp = (-b * z) * c elif i <= 8.2e-60: 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) * t) tmp = 0.0 if (i <= -1.7e+170) tmp = t_1; elseif (i <= -6.7e-234) tmp = Float64(Float64(Float64(-b) * z) * c); elseif (i <= 8.2e-60) 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) * t; tmp = 0.0; if (i <= -1.7e+170) tmp = t_1; elseif (i <= -6.7e-234) tmp = (-b * z) * c; elseif (i <= 8.2e-60) 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] * t), $MachinePrecision]}, If[LessEqual[i, -1.7e+170], t$95$1, If[LessEqual[i, -6.7e-234], N[(N[((-b) * z), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[i, 8.2e-60], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot t\\
\mathbf{if}\;i \leq -1.7 \cdot 10^{+170}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -6.7 \cdot 10^{-234}:\\
\;\;\;\;\left(\left(-b\right) \cdot z\right) \cdot c\\
\mathbf{elif}\;i \leq 8.2 \cdot 10^{-60}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.7000000000000001e170 or 8.20000000000000025e-60 < i Initial program 76.3%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6475.2
Applied rewrites75.2%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/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-*.f6451.5
Applied rewrites51.5%
Taylor expanded in x around 0
Applied rewrites45.0%
if -1.7000000000000001e170 < i < -6.7e-234Initial program 79.3%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6443.1
Applied rewrites43.1%
Taylor expanded in x around inf
Applied rewrites14.1%
Taylor expanded in x around 0
Applied rewrites28.1%
if -6.7e-234 < i < 8.20000000000000025e-60Initial program 78.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.6
Applied rewrites54.6%
Taylor expanded in x around inf
Applied rewrites36.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* z x) y)))
(if (<= z -6e+149)
t_1
(if (<= z -1.92e+46) (* (* j c) a) (if (<= z 65.0) (* (* i b) 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+149) {
tmp = t_1;
} else if (z <= -1.92e+46) {
tmp = (j * c) * a;
} else if (z <= 65.0) {
tmp = (i * b) * 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+149)) then
tmp = t_1
else if (z <= (-1.92d+46)) then
tmp = (j * c) * a
else if (z <= 65.0d0) then
tmp = (i * b) * 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+149) {
tmp = t_1;
} else if (z <= -1.92e+46) {
tmp = (j * c) * a;
} else if (z <= 65.0) {
tmp = (i * b) * 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+149: tmp = t_1 elif z <= -1.92e+46: tmp = (j * c) * a elif z <= 65.0: tmp = (i * b) * 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+149) tmp = t_1; elseif (z <= -1.92e+46) tmp = Float64(Float64(j * c) * a); elseif (z <= 65.0) tmp = Float64(Float64(i * b) * 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+149) tmp = t_1; elseif (z <= -1.92e+46) tmp = (j * c) * a; elseif (z <= 65.0) tmp = (i * b) * 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+149], t$95$1, If[LessEqual[z, -1.92e+46], N[(N[(j * c), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[z, 65.0], N[(N[(i * b), $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^{+149}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.92 \cdot 10^{+46}:\\
\;\;\;\;\left(j \cdot c\right) \cdot a\\
\mathbf{elif}\;z \leq 65:\\
\;\;\;\;\left(i \cdot b\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -6.00000000000000007e149 or 65 < z Initial program 70.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.1
Applied rewrites69.1%
Taylor expanded in x around inf
Applied rewrites37.5%
Applied rewrites39.7%
if -6.00000000000000007e149 < z < -1.91999999999999992e46Initial program 73.6%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6473.6
Applied rewrites73.6%
Taylor expanded in a around inf
*-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-*.f6457.2
Applied rewrites57.2%
Taylor expanded in x around 0
Applied rewrites39.7%
if -1.91999999999999992e46 < z < 65Initial program 83.2%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6481.8
Applied rewrites81.8%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/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-*.f6451.5
Applied rewrites51.5%
Taylor expanded in x around 0
Applied rewrites32.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= z -2.4e-64) (* (* (- z) c) b) (if (<= z 1.2e+26) (* (* b t) i) (* (* z x) y))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.4e-64) {
tmp = (-z * c) * b;
} else if (z <= 1.2e+26) {
tmp = (b * t) * i;
} else {
tmp = (z * x) * y;
}
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 <= (-2.4d-64)) then
tmp = (-z * c) * b
else if (z <= 1.2d+26) then
tmp = (b * t) * i
else
tmp = (z * x) * y
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 <= -2.4e-64) {
tmp = (-z * c) * b;
} else if (z <= 1.2e+26) {
tmp = (b * t) * i;
} else {
tmp = (z * x) * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -2.4e-64: tmp = (-z * c) * b elif z <= 1.2e+26: tmp = (b * t) * i else: tmp = (z * x) * y return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -2.4e-64) tmp = Float64(Float64(Float64(-z) * c) * b); elseif (z <= 1.2e+26) tmp = Float64(Float64(b * t) * i); else tmp = Float64(Float64(z * x) * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -2.4e-64) tmp = (-z * c) * b; elseif (z <= 1.2e+26) tmp = (b * t) * i; else tmp = (z * x) * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -2.4e-64], N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[z, 1.2e+26], N[(N[(b * t), $MachinePrecision] * i), $MachinePrecision], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.4 \cdot 10^{-64}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{+26}:\\
\;\;\;\;\left(b \cdot t\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\end{array}
\end{array}
if z < -2.39999999999999998e-64Initial program 73.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6453.7
Applied rewrites53.7%
Taylor expanded in x around 0
Applied rewrites39.2%
if -2.39999999999999998e-64 < z < 1.20000000000000002e26Initial program 84.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
lower-*.f6456.4
Applied rewrites56.4%
Taylor expanded in y around 0
Applied rewrites33.1%
if 1.20000000000000002e26 < z Initial program 68.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.2
Applied rewrites69.2%
Taylor expanded in x around inf
Applied rewrites40.5%
Applied rewrites40.8%
Final simplification36.4%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* z x) y))) (if (<= z -9.2e+78) t_1 (if (<= z 65.0) (* (* i b) 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 <= -9.2e+78) {
tmp = t_1;
} else if (z <= 65.0) {
tmp = (i * b) * 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 <= (-9.2d+78)) then
tmp = t_1
else if (z <= 65.0d0) then
tmp = (i * b) * 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 <= -9.2e+78) {
tmp = t_1;
} else if (z <= 65.0) {
tmp = (i * b) * 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 <= -9.2e+78: tmp = t_1 elif z <= 65.0: tmp = (i * b) * 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 <= -9.2e+78) tmp = t_1; elseif (z <= 65.0) tmp = Float64(Float64(i * b) * 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 <= -9.2e+78) tmp = t_1; elseif (z <= 65.0) tmp = (i * b) * 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, -9.2e+78], t$95$1, If[LessEqual[z, 65.0], N[(N[(i * b), $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 -9.2 \cdot 10^{+78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 65:\\
\;\;\;\;\left(i \cdot b\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -9.2000000000000008e78 or 65 < z Initial program 70.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6466.1
Applied rewrites66.1%
Taylor expanded in x around inf
Applied rewrites35.3%
Applied rewrites36.4%
if -9.2000000000000008e78 < z < 65Initial program 83.1%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-*.f6481.8
Applied rewrites81.8%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/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-*.f6450.0
Applied rewrites50.0%
Taylor expanded in x around 0
Applied rewrites31.2%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* z x) y))) (if (<= z -1.05e+81) t_1 (if (<= z 1.2e+26) (* (* b t) 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 * x) * y;
double tmp;
if (z <= -1.05e+81) {
tmp = t_1;
} else if (z <= 1.2e+26) {
tmp = (b * t) * i;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (z * x) * y
if (z <= (-1.05d+81)) then
tmp = t_1
else if (z <= 1.2d+26) then
tmp = (b * t) * i
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (z * x) * y;
double tmp;
if (z <= -1.05e+81) {
tmp = t_1;
} else if (z <= 1.2e+26) {
tmp = (b * t) * i;
} 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 <= -1.05e+81: tmp = t_1 elif z <= 1.2e+26: tmp = (b * t) * i 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 <= -1.05e+81) tmp = t_1; elseif (z <= 1.2e+26) tmp = Float64(Float64(b * t) * i); 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 <= -1.05e+81) tmp = t_1; elseif (z <= 1.2e+26) tmp = (b * t) * i; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision]}, If[LessEqual[z, -1.05e+81], t$95$1, If[LessEqual[z, 1.2e+26], N[(N[(b * t), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot x\right) \cdot y\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{+81}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{+26}:\\
\;\;\;\;\left(b \cdot t\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.0499999999999999e81 or 1.20000000000000002e26 < z Initial program 68.1%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6467.6
Applied rewrites67.6%
Taylor expanded in x around inf
Applied rewrites36.6%
Applied rewrites37.7%
if -1.0499999999999999e81 < z < 1.20000000000000002e26Initial program 83.8%
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
lower-*.f6450.6
Applied rewrites50.6%
Taylor expanded in y around 0
Applied rewrites30.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= z -1.05e+81) (* (* z x) y) (if (<= z 2.4e-107) (* (* i t) 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 (z <= -1.05e+81) {
tmp = (z * x) * y;
} else if (z <= 2.4e-107) {
tmp = (i * t) * b;
} else {
tmp = (y * x) * 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 <= (-1.05d+81)) then
tmp = (z * x) * y
else if (z <= 2.4d-107) then
tmp = (i * t) * b
else
tmp = (y * x) * 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 <= -1.05e+81) {
tmp = (z * x) * y;
} else if (z <= 2.4e-107) {
tmp = (i * t) * b;
} else {
tmp = (y * x) * z;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -1.05e+81: tmp = (z * x) * y elif z <= 2.4e-107: tmp = (i * t) * b else: tmp = (y * x) * z return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -1.05e+81) tmp = Float64(Float64(z * x) * y); elseif (z <= 2.4e-107) tmp = Float64(Float64(i * t) * b); else tmp = Float64(Float64(y * x) * z); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -1.05e+81) tmp = (z * x) * y; elseif (z <= 2.4e-107) tmp = (i * t) * b; else tmp = (y * x) * z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -1.05e+81], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, 2.4e-107], N[(N[(i * t), $MachinePrecision] * b), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.05 \cdot 10^{+81}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{-107}:\\
\;\;\;\;\left(i \cdot t\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\end{array}
\end{array}
if z < -1.0499999999999999e81Initial program 67.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6465.9
Applied rewrites65.9%
Taylor expanded in x around inf
Applied rewrites32.4%
Applied rewrites34.4%
if -1.0499999999999999e81 < z < 2.39999999999999994e-107Initial program 81.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
lower-*.f6449.9
Applied rewrites49.9%
Taylor expanded in y around 0
Applied rewrites31.2%
if 2.39999999999999994e-107 < z Initial program 78.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6455.6
Applied rewrites55.6%
Taylor expanded in x around inf
Applied rewrites33.7%
Final simplification32.6%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* z x) y))) (if (<= z -1.05e+81) t_1 (if (<= z 65.0) (* (* i t) b) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (z * x) * y;
double tmp;
if (z <= -1.05e+81) {
tmp = t_1;
} else if (z <= 65.0) {
tmp = (i * t) * b;
} 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 <= (-1.05d+81)) then
tmp = t_1
else if (z <= 65.0d0) then
tmp = (i * t) * b
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 <= -1.05e+81) {
tmp = t_1;
} else if (z <= 65.0) {
tmp = (i * t) * b;
} 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 <= -1.05e+81: tmp = t_1 elif z <= 65.0: tmp = (i * t) * b 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 <= -1.05e+81) tmp = t_1; elseif (z <= 65.0) tmp = Float64(Float64(i * t) * b); 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 <= -1.05e+81) tmp = t_1; elseif (z <= 65.0) tmp = (i * t) * b; 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, -1.05e+81], t$95$1, If[LessEqual[z, 65.0], N[(N[(i * t), $MachinePrecision] * b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot x\right) \cdot y\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{+81}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 65:\\
\;\;\;\;\left(i \cdot t\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.0499999999999999e81 or 65 < z Initial program 69.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6465.7
Applied rewrites65.7%
Taylor expanded in x around inf
Applied rewrites35.6%
Applied rewrites36.7%
if -1.0499999999999999e81 < z < 65Initial program 83.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
lower-*.f6449.3
Applied rewrites49.3%
Taylor expanded in y around 0
Applied rewrites29.8%
Final simplification32.5%
(FPCore (x y z t a b c i j) :precision binary64 (* (* z x) y))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * x) * y;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = (z * x) * y
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * x) * y;
}
def code(x, y, z, t, a, b, c, i, j): return (z * x) * y
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(z * x) * y) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (z * x) * y; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision]
\begin{array}{l}
\\
\left(z \cdot x\right) \cdot y
\end{array}
Initial program 77.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6439.9
Applied rewrites39.9%
Taylor expanded in x around inf
Applied rewrites20.0%
Applied rewrites20.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* c a) (* y i))))
(t_2
(+
(-
(* x (- (* y z) (* t a)))
(/
(* b (- (pow (* c z) 2.0) (pow (* t i) 2.0)))
(+ (* c z) (* t i))))
t_1)))
(if (< x -1.469694296777705e-64)
t_2
(if (< x 3.2113527362226803e-147)
(- (* (- (* b i) (* x a)) t) (- (* z (* c b)) t_1))
t_2))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((c * a) - (y * i));
double t_2 = ((x * ((y * z) - (t * a))) - ((b * (pow((c * z), 2.0) - pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
double tmp;
if (x < -1.469694296777705e-64) {
tmp = t_2;
} else if (x < 3.2113527362226803e-147) {
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1);
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = j * ((c * a) - (y * i))
t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ** 2.0d0) - ((t * i) ** 2.0d0))) / ((c * z) + (t * i)))) + t_1
if (x < (-1.469694296777705d-64)) then
tmp = t_2
else if (x < 3.2113527362226803d-147) then
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1)
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((c * a) - (y * i));
double t_2 = ((x * ((y * z) - (t * a))) - ((b * (Math.pow((c * z), 2.0) - Math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
double tmp;
if (x < -1.469694296777705e-64) {
tmp = t_2;
} else if (x < 3.2113527362226803e-147) {
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((c * a) - (y * i)) t_2 = ((x * ((y * z) - (t * a))) - ((b * (math.pow((c * z), 2.0) - math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1 tmp = 0 if x < -1.469694296777705e-64: tmp = t_2 elif x < 3.2113527362226803e-147: tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(c * a) - Float64(y * i))) t_2 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(Float64(b * Float64((Float64(c * z) ^ 2.0) - (Float64(t * i) ^ 2.0))) / Float64(Float64(c * z) + Float64(t * i)))) + t_1) tmp = 0.0 if (x < -1.469694296777705e-64) tmp = t_2; elseif (x < 3.2113527362226803e-147) tmp = Float64(Float64(Float64(Float64(b * i) - Float64(x * a)) * t) - Float64(Float64(z * Float64(c * b)) - t_1)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = j * ((c * a) - (y * i)); t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ^ 2.0) - ((t * i) ^ 2.0))) / ((c * z) + (t * i)))) + t_1; tmp = 0.0; if (x < -1.469694296777705e-64) tmp = t_2; elseif (x < 3.2113527362226803e-147) tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[Power[N[(c * z), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(t * i), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * z), $MachinePrecision] + N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[Less[x, -1.469694296777705e-64], t$95$2, If[Less[x, 3.2113527362226803e-147], N[(N[(N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] - N[(N[(z * N[(c * b), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(c \cdot a - y \cdot i\right)\\
t_2 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - \frac{b \cdot \left({\left(c \cdot z\right)}^{2} - {\left(t \cdot i\right)}^{2}\right)}{c \cdot z + t \cdot i}\right) + t\_1\\
\mathbf{if}\;x < -1.469694296777705 \cdot 10^{-64}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x < 3.2113527362226803 \cdot 10^{-147}:\\
\;\;\;\;\left(b \cdot i - x \cdot a\right) \cdot t - \left(z \cdot \left(c \cdot b\right) - t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024331
(FPCore (x y z t a b c i j)
:name "Data.Colour.Matrix:determinant from colour-2.3.3, A"
:precision binary64
:alt
(! :herbie-platform default (if (< x -293938859355541/2000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2) (pow (* t i) 2))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i)))) (if (< x 32113527362226803/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (* (- (* b i) (* x a)) t) (- (* z (* c b)) (* j (- (* c a) (* y i))))) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2) (pow (* t i) 2))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i)))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))