
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 27 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(-
(* (- (* c t) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b)))))
(if (<= t_1 INFINITY) t_1 (* (fma i b (* (- t) x)) a))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(i, b, (-t * x)) * a;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(fma(i, b, Float64(Float64(-t) * x)) * a); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[(i * b + N[((-t) * x), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot t - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(i, b, \left(-t\right) \cdot x\right) \cdot a\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 91.4%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Applied rewrites16.7%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6462.5
Applied rewrites62.5%
Applied rewrites64.9%
Final simplification87.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.7e+23)
t_1
(if (<= x -1.05e-74)
(* (fma (- b) z (* j t)) c)
(if (<= x -3.5e-240)
(* (fma (- i) y (* c t)) j)
(if (<= x 1.95e-146)
(* (fma (- y) j (* b a)) i)
(if (<= x 2.95e+91)
(+ (* (* (- j) y) i) (* (* (- z) c) 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 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.7e+23) {
tmp = t_1;
} else if (x <= -1.05e-74) {
tmp = fma(-b, z, (j * t)) * c;
} else if (x <= -3.5e-240) {
tmp = fma(-i, y, (c * t)) * j;
} else if (x <= 1.95e-146) {
tmp = fma(-y, j, (b * a)) * i;
} else if (x <= 2.95e+91) {
tmp = ((-j * y) * i) + ((-z * c) * b);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.7e+23) tmp = t_1; elseif (x <= -1.05e-74) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); elseif (x <= -3.5e-240) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); elseif (x <= 1.95e-146) tmp = Float64(fma(Float64(-y), j, Float64(b * a)) * i); elseif (x <= 2.95e+91) tmp = Float64(Float64(Float64(Float64(-j) * y) * i) + Float64(Float64(Float64(-z) * c) * b)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.7e+23], t$95$1, If[LessEqual[x, -1.05e-74], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, -3.5e-240], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[x, 1.95e-146], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[x, 2.95e+91], N[(N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision] + N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.7 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.05 \cdot 10^{-74}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{elif}\;x \leq -3.5 \cdot 10^{-240}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{elif}\;x \leq 1.95 \cdot 10^{-146}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot a\right) \cdot i\\
\mathbf{elif}\;x \leq 2.95 \cdot 10^{+91}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i + \left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.6999999999999997e23 or 2.9500000000000001e91 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -4.6999999999999997e23 < x < -1.05e-74Initial program 59.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.6
Applied rewrites71.6%
if -1.05e-74 < x < -3.50000000000000016e-240Initial program 81.3%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6463.0
Applied rewrites63.0%
if -3.50000000000000016e-240 < x < 1.95000000000000001e-146Initial program 80.9%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6466.4
Applied rewrites66.4%
if 1.95000000000000001e-146 < x < 2.9500000000000001e91Initial program 76.0%
Taylor expanded in c around inf
associate-*r*N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6460.8
Applied rewrites60.8%
Taylor expanded in c around 0
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.3
Applied rewrites51.3%
Final simplification66.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -6.8e+25)
t_1
(if (<= x -1.75e-209)
(fma (fma (- c) z (* i a)) b (* (* j c) t))
(if (<= x 2.2e-144)
(+ (* (* i b) a) (* (- (* c t) (* i y)) j))
(if (<= x 9.2e+91)
(- (* (* (- z) c) b) (* (- (* i y) (* c t)) j))
t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -6.8e+25) {
tmp = t_1;
} else if (x <= -1.75e-209) {
tmp = fma(fma(-c, z, (i * a)), b, ((j * c) * t));
} else if (x <= 2.2e-144) {
tmp = ((i * b) * a) + (((c * t) - (i * y)) * j);
} else if (x <= 9.2e+91) {
tmp = ((-z * c) * b) - (((i * y) - (c * t)) * j);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -6.8e+25) tmp = t_1; elseif (x <= -1.75e-209) tmp = fma(fma(Float64(-c), z, Float64(i * a)), b, Float64(Float64(j * c) * t)); elseif (x <= 2.2e-144) tmp = Float64(Float64(Float64(i * b) * a) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); elseif (x <= 9.2e+91) tmp = Float64(Float64(Float64(Float64(-z) * c) * b) - Float64(Float64(Float64(i * y) - Float64(c * t)) * j)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -6.8e+25], t$95$1, If[LessEqual[x, -1.75e-209], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.2e-144], N[(N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.2e+91], N[(N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision] - N[(N[(N[(i * y), $MachinePrecision] - N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -6.8 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.75 \cdot 10^{-209}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, z, i \cdot a\right), b, \left(j \cdot c\right) \cdot t\right)\\
\mathbf{elif}\;x \leq 2.2 \cdot 10^{-144}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{elif}\;x \leq 9.2 \cdot 10^{+91}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b - \left(i \cdot y - c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -6.79999999999999967e25 or 9.19999999999999965e91 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -6.79999999999999967e25 < x < -1.75000000000000001e-209Initial program 74.9%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites68.4%
Taylor expanded in c around inf
Applied rewrites68.4%
if -1.75000000000000001e-209 < x < 2.20000000000000006e-144Initial program 80.8%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6477.1
Applied rewrites77.1%
if 2.20000000000000006e-144 < x < 9.19999999999999965e91Initial program 75.5%
Taylor expanded in c around inf
associate-*r*N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6460.2
Applied rewrites60.2%
Final simplification72.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (- c) z (* i a))) (t_2 (* (fma (- a) t (* z y)) x)))
(if (<= x -6.8e+25)
t_2
(if (<= x -1.75e-209)
(fma t_1 b (* (* j c) t))
(if (<= x 5.3e-235)
(+ (* (* i b) a) (* (- (* c t) (* i y)) j))
(if (<= x 4.3e+95) (fma t_1 b (* (* (- y) i) j)) t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-c, z, (i * a));
double t_2 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -6.8e+25) {
tmp = t_2;
} else if (x <= -1.75e-209) {
tmp = fma(t_1, b, ((j * c) * t));
} else if (x <= 5.3e-235) {
tmp = ((i * b) * a) + (((c * t) - (i * y)) * j);
} else if (x <= 4.3e+95) {
tmp = fma(t_1, b, ((-y * i) * j));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(-c), z, Float64(i * a)) t_2 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -6.8e+25) tmp = t_2; elseif (x <= -1.75e-209) tmp = fma(t_1, b, Float64(Float64(j * c) * t)); elseif (x <= 5.3e-235) tmp = Float64(Float64(Float64(i * b) * a) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); elseif (x <= 4.3e+95) tmp = fma(t_1, b, Float64(Float64(Float64(-y) * i) * j)); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -6.8e+25], t$95$2, If[LessEqual[x, -1.75e-209], N[(t$95$1 * b + N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 5.3e-235], N[(N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.3e+95], N[(t$95$1 * b + N[(N[((-y) * i), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, z, i \cdot a\right)\\
t_2 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -6.8 \cdot 10^{+25}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.75 \cdot 10^{-209}:\\
\;\;\;\;\mathsf{fma}\left(t\_1, b, \left(j \cdot c\right) \cdot t\right)\\
\mathbf{elif}\;x \leq 5.3 \cdot 10^{-235}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{elif}\;x \leq 4.3 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(t\_1, b, \left(\left(-y\right) \cdot i\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -6.79999999999999967e25 or 4.3e95 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -6.79999999999999967e25 < x < -1.75000000000000001e-209Initial program 74.9%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites68.4%
Taylor expanded in c around inf
Applied rewrites68.4%
if -1.75000000000000001e-209 < x < 5.3000000000000002e-235Initial program 78.1%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6477.6
Applied rewrites77.6%
if 5.3000000000000002e-235 < x < 4.3e95Initial program 78.3%
Taylor expanded in x around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites68.3%
Taylor expanded in c around 0
Applied rewrites63.6%
Final simplification71.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (- c) z (* i a))) (t_2 (* (fma (- a) t (* z y)) x)))
(if (<= x -6.8e+25)
t_2
(if (<= x -3.7e-294)
(fma t_1 b (* (* j c) t))
(if (<= x 4.3e+95) (fma t_1 b (* (* (- y) i) j)) t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-c, z, (i * a));
double t_2 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -6.8e+25) {
tmp = t_2;
} else if (x <= -3.7e-294) {
tmp = fma(t_1, b, ((j * c) * t));
} else if (x <= 4.3e+95) {
tmp = fma(t_1, b, ((-y * i) * j));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(-c), z, Float64(i * a)) t_2 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -6.8e+25) tmp = t_2; elseif (x <= -3.7e-294) tmp = fma(t_1, b, Float64(Float64(j * c) * t)); elseif (x <= 4.3e+95) tmp = fma(t_1, b, Float64(Float64(Float64(-y) * i) * j)); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -6.8e+25], t$95$2, If[LessEqual[x, -3.7e-294], N[(t$95$1 * b + N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.3e+95], N[(t$95$1 * b + N[(N[((-y) * i), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-c, z, i \cdot a\right)\\
t_2 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -6.8 \cdot 10^{+25}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -3.7 \cdot 10^{-294}:\\
\;\;\;\;\mathsf{fma}\left(t\_1, b, \left(j \cdot c\right) \cdot t\right)\\
\mathbf{elif}\;x \leq 4.3 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(t\_1, b, \left(\left(-y\right) \cdot i\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -6.79999999999999967e25 or 4.3e95 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -6.79999999999999967e25 < x < -3.69999999999999994e-294Initial program 71.1%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites64.4%
Taylor expanded in c around inf
Applied rewrites64.5%
if -3.69999999999999994e-294 < x < 4.3e95Initial program 81.2%
Taylor expanded in x around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites73.7%
Taylor expanded in c around 0
Applied rewrites66.2%
Final simplification69.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -6.8e+25)
t_1
(if (<= x 8.2e-81)
(fma (fma (- c) z (* i a)) b (* (* j c) t))
(if (<= x 2.85e+91) (* (* (fma i (/ j z) (- x)) (- z)) 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(-a, t, (z * y)) * x;
double tmp;
if (x <= -6.8e+25) {
tmp = t_1;
} else if (x <= 8.2e-81) {
tmp = fma(fma(-c, z, (i * a)), b, ((j * c) * t));
} else if (x <= 2.85e+91) {
tmp = (fma(i, (j / z), -x) * -z) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -6.8e+25) tmp = t_1; elseif (x <= 8.2e-81) tmp = fma(fma(Float64(-c), z, Float64(i * a)), b, Float64(Float64(j * c) * t)); elseif (x <= 2.85e+91) tmp = Float64(Float64(fma(i, Float64(j / z), Float64(-x)) * Float64(-z)) * 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[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -6.8e+25], t$95$1, If[LessEqual[x, 8.2e-81], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.85e+91], N[(N[(N[(i * N[(j / z), $MachinePrecision] + (-x)), $MachinePrecision] * (-z)), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -6.8 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 8.2 \cdot 10^{-81}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, z, i \cdot a\right), b, \left(j \cdot c\right) \cdot t\right)\\
\mathbf{elif}\;x \leq 2.85 \cdot 10^{+91}:\\
\;\;\;\;\left(\mathsf{fma}\left(i, \frac{j}{z}, -x\right) \cdot \left(-z\right)\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -6.79999999999999967e25 or 2.84999999999999982e91 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -6.79999999999999967e25 < x < 8.19999999999999968e-81Initial program 79.5%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites65.7%
Taylor expanded in c around inf
Applied rewrites65.7%
if 8.19999999999999968e-81 < x < 2.84999999999999982e91Initial program 70.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.7
Applied rewrites51.7%
Taylor expanded in z around -inf
Applied rewrites51.8%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -1.06e+26)
t_1
(if (<= x 4.3e+95)
(fma (fma (- c) z (* i a)) b (* (fma (- i) y (* c t)) j))
t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -1.06e+26) {
tmp = t_1;
} else if (x <= 4.3e+95) {
tmp = fma(fma(-c, z, (i * a)), b, (fma(-i, y, (c * t)) * j));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -1.06e+26) tmp = t_1; elseif (x <= 4.3e+95) tmp = fma(fma(Float64(-c), z, Float64(i * a)), b, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.06e+26], t$95$1, If[LessEqual[x, 4.3e+95], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -1.06 \cdot 10^{+26}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.3 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, z, i \cdot a\right), b, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.05999999999999997e26 or 4.3e95 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -1.05999999999999997e26 < x < 4.3e95Initial program 77.1%
Taylor expanded in x around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites73.8%
Final simplification75.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.7e+23)
t_1
(if (<= x -1.05e-74)
(* (fma (- b) z (* j t)) c)
(if (<= x -3.5e-240)
(* (fma (- i) y (* c t)) j)
(if (<= x 1.7e-49)
(* (fma (- y) j (* b a)) i)
(if (<= x 1.35e+95) (* (fma (- b) c (* y x)) z) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.7e+23) {
tmp = t_1;
} else if (x <= -1.05e-74) {
tmp = fma(-b, z, (j * t)) * c;
} else if (x <= -3.5e-240) {
tmp = fma(-i, y, (c * t)) * j;
} else if (x <= 1.7e-49) {
tmp = fma(-y, j, (b * a)) * i;
} else if (x <= 1.35e+95) {
tmp = fma(-b, c, (y * x)) * z;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.7e+23) tmp = t_1; elseif (x <= -1.05e-74) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); elseif (x <= -3.5e-240) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); elseif (x <= 1.7e-49) tmp = Float64(fma(Float64(-y), j, Float64(b * a)) * i); elseif (x <= 1.35e+95) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.7e+23], t$95$1, If[LessEqual[x, -1.05e-74], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, -3.5e-240], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[x, 1.7e-49], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[x, 1.35e+95], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.7 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.05 \cdot 10^{-74}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{elif}\;x \leq -3.5 \cdot 10^{-240}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{-49}:\\
\;\;\;\;\mathsf{fma}\left(-y, j, b \cdot a\right) \cdot i\\
\mathbf{elif}\;x \leq 1.35 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.6999999999999997e23 or 1.35e95 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -4.6999999999999997e23 < x < -1.05e-74Initial program 59.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.6
Applied rewrites71.6%
if -1.05e-74 < x < -3.50000000000000016e-240Initial program 81.3%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6463.0
Applied rewrites63.0%
if -3.50000000000000016e-240 < x < 1.70000000000000002e-49Initial program 81.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
*-commutativeN/A
lower-*.f6460.8
Applied rewrites60.8%
if 1.70000000000000002e-49 < x < 1.35e95Initial program 72.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6452.3
Applied rewrites52.3%
Final simplification66.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.7e+23)
t_1
(if (<= x -1.05e-74)
(* (fma (- b) z (* j t)) c)
(if (<= x 1.75e-181)
(* (fma (- i) y (* c t)) j)
(if (<= x 5.8e-81)
(* (fma (- c) z (* i a)) b)
(if (<= x 2.85e+91) (* (fma (- j) i (* z x)) y) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.7e+23) {
tmp = t_1;
} else if (x <= -1.05e-74) {
tmp = fma(-b, z, (j * t)) * c;
} else if (x <= 1.75e-181) {
tmp = fma(-i, y, (c * t)) * j;
} else if (x <= 5.8e-81) {
tmp = fma(-c, z, (i * a)) * b;
} else if (x <= 2.85e+91) {
tmp = fma(-j, i, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.7e+23) tmp = t_1; elseif (x <= -1.05e-74) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); elseif (x <= 1.75e-181) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); elseif (x <= 5.8e-81) tmp = Float64(fma(Float64(-c), z, Float64(i * a)) * b); elseif (x <= 2.85e+91) tmp = Float64(fma(Float64(-j), i, Float64(z * x)) * y); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.7e+23], t$95$1, If[LessEqual[x, -1.05e-74], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 1.75e-181], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[x, 5.8e-81], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 2.85e+91], N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.7 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.05 \cdot 10^{-74}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{elif}\;x \leq 1.75 \cdot 10^{-181}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{elif}\;x \leq 5.8 \cdot 10^{-81}:\\
\;\;\;\;\mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{elif}\;x \leq 2.85 \cdot 10^{+91}:\\
\;\;\;\;\mathsf{fma}\left(-j, i, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.6999999999999997e23 or 2.84999999999999982e91 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -4.6999999999999997e23 < x < -1.05e-74Initial program 59.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.6
Applied rewrites71.6%
if -1.05e-74 < x < 1.74999999999999998e-181Initial program 80.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6458.6
Applied rewrites58.6%
if 1.74999999999999998e-181 < x < 5.79999999999999978e-81Initial program 90.8%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6469.3
Applied rewrites69.3%
if 5.79999999999999978e-81 < x < 2.84999999999999982e91Initial program 70.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.7
Applied rewrites51.7%
Final simplification66.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.7e+23)
t_1
(if (<= x -1.05e-74)
(* (fma (- b) z (* j t)) c)
(if (<= x 1.75e-181)
(* (fma (- i) y (* c t)) j)
(if (<= x 1.7e-49)
(* (fma (- c) z (* i a)) b)
(if (<= x 1.35e+95) (* (fma (- b) c (* y x)) z) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.7e+23) {
tmp = t_1;
} else if (x <= -1.05e-74) {
tmp = fma(-b, z, (j * t)) * c;
} else if (x <= 1.75e-181) {
tmp = fma(-i, y, (c * t)) * j;
} else if (x <= 1.7e-49) {
tmp = fma(-c, z, (i * a)) * b;
} else if (x <= 1.35e+95) {
tmp = fma(-b, c, (y * x)) * z;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.7e+23) tmp = t_1; elseif (x <= -1.05e-74) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); elseif (x <= 1.75e-181) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); elseif (x <= 1.7e-49) tmp = Float64(fma(Float64(-c), z, Float64(i * a)) * b); elseif (x <= 1.35e+95) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.7e+23], t$95$1, If[LessEqual[x, -1.05e-74], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 1.75e-181], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[x, 1.7e-49], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 1.35e+95], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.7 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.05 \cdot 10^{-74}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{elif}\;x \leq 1.75 \cdot 10^{-181}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{-49}:\\
\;\;\;\;\mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{elif}\;x \leq 1.35 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.6999999999999997e23 or 1.35e95 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -4.6999999999999997e23 < x < -1.05e-74Initial program 59.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.6
Applied rewrites71.6%
if -1.05e-74 < x < 1.74999999999999998e-181Initial program 80.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
+-commutativeN/A
neg-mul-1N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6458.6
Applied rewrites58.6%
if 1.74999999999999998e-181 < x < 1.70000000000000002e-49Initial 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
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6459.7
Applied rewrites59.7%
if 1.70000000000000002e-49 < x < 1.35e95Initial program 72.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6452.3
Applied rewrites52.3%
Final simplification65.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)) (t_2 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.4e+21)
t_2
(if (<= x -9.2e-58)
t_1
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 4e-146) (* (* i b) a) (if (<= x 1.35e+95) t_1 t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-b, c, (y * x)) * z;
double t_2 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.4e+21) {
tmp = t_2;
} else if (x <= -9.2e-58) {
tmp = t_1;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 4e-146) {
tmp = (i * b) * a;
} else if (x <= 1.35e+95) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), c, Float64(y * x)) * z) t_2 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.4e+21) tmp = t_2; elseif (x <= -9.2e-58) tmp = t_1; elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 4e-146) tmp = Float64(Float64(i * b) * a); elseif (x <= 1.35e+95) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.4e+21], t$95$2, If[LessEqual[x, -9.2e-58], t$95$1, If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 4e-146], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 1.35e+95], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
t_2 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.4 \cdot 10^{+21}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -9.2 \cdot 10^{-58}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 4 \cdot 10^{-146}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 1.35 \cdot 10^{+95}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -4.4e21 or 1.35e95 < x Initial program 75.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6477.4
Applied rewrites77.4%
if -4.4e21 < x < -9.1999999999999995e-58 or 4.0000000000000001e-146 < x < 1.35e95Initial program 72.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6450.0
Applied rewrites50.0%
if -9.1999999999999995e-58 < x < -4.1000000000000001e-240Initial program 79.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.3%
Taylor expanded in j around inf
Applied rewrites40.4%
Applied rewrites42.7%
if -4.1000000000000001e-240 < x < 4.0000000000000001e-146Initial program 80.9%
Applied rewrites80.8%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6443.7
Applied rewrites43.7%
Taylor expanded in b around inf
Applied rewrites43.6%
Final simplification56.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -3.5e+25)
(* (* a x) (- t))
(if (<= x -3.1e-56)
(* (* (- b) c) z)
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 3.8e-274)
(* (* i b) a)
(if (<= x 5.4e+70) (* (* (- j) i) y) (* (* (- a) t) x)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -3.5e+25) {
tmp = (a * x) * -t;
} else if (x <= -3.1e-56) {
tmp = (-b * c) * z;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 3.8e-274) {
tmp = (i * b) * a;
} else if (x <= 5.4e+70) {
tmp = (-j * i) * y;
} else {
tmp = (-a * t) * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (x <= (-3.5d+25)) then
tmp = (a * x) * -t
else if (x <= (-3.1d-56)) then
tmp = (-b * c) * z
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 3.8d-274) then
tmp = (i * b) * a
else if (x <= 5.4d+70) then
tmp = (-j * i) * y
else
tmp = (-a * t) * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -3.5e+25) {
tmp = (a * x) * -t;
} else if (x <= -3.1e-56) {
tmp = (-b * c) * z;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 3.8e-274) {
tmp = (i * b) * a;
} else if (x <= 5.4e+70) {
tmp = (-j * i) * y;
} else {
tmp = (-a * t) * x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -3.5e+25: tmp = (a * x) * -t elif x <= -3.1e-56: tmp = (-b * c) * z elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 3.8e-274: tmp = (i * b) * a elif x <= 5.4e+70: tmp = (-j * i) * y else: tmp = (-a * t) * x return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -3.5e+25) tmp = Float64(Float64(a * x) * Float64(-t)); elseif (x <= -3.1e-56) tmp = Float64(Float64(Float64(-b) * c) * z); elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 3.8e-274) tmp = Float64(Float64(i * b) * a); elseif (x <= 5.4e+70) tmp = Float64(Float64(Float64(-j) * i) * y); else tmp = Float64(Float64(Float64(-a) * t) * x); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -3.5e+25) tmp = (a * x) * -t; elseif (x <= -3.1e-56) tmp = (-b * c) * z; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 3.8e-274) tmp = (i * b) * a; elseif (x <= 5.4e+70) tmp = (-j * i) * y; else tmp = (-a * t) * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -3.5e+25], N[(N[(a * x), $MachinePrecision] * (-t)), $MachinePrecision], If[LessEqual[x, -3.1e-56], N[(N[((-b) * c), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 3.8e-274], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 5.4e+70], N[(N[((-j) * i), $MachinePrecision] * y), $MachinePrecision], N[(N[((-a) * t), $MachinePrecision] * x), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.5 \cdot 10^{+25}:\\
\;\;\;\;\left(a \cdot x\right) \cdot \left(-t\right)\\
\mathbf{elif}\;x \leq -3.1 \cdot 10^{-56}:\\
\;\;\;\;\left(\left(-b\right) \cdot c\right) \cdot z\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{-274}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 5.4 \cdot 10^{+70}:\\
\;\;\;\;\left(\left(-j\right) \cdot i\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-a\right) \cdot t\right) \cdot x\\
\end{array}
\end{array}
if x < -3.49999999999999999e25Initial program 74.8%
Taylor expanded in t around -inf
Applied rewrites75.5%
Taylor expanded in a around inf
Applied rewrites59.1%
Taylor expanded in b around 0
Applied rewrites55.6%
if -3.49999999999999999e25 < x < -3.09999999999999987e-56Initial program 58.9%
Applied rewrites67.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6418.8
Applied rewrites18.8%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/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-*.f6475.5
Applied rewrites75.5%
Taylor expanded in c around inf
Applied rewrites67.5%
if -3.09999999999999987e-56 < x < -4.1000000000000001e-240Initial program 79.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.3%
Taylor expanded in j around inf
Applied rewrites40.4%
Applied rewrites42.7%
if -4.1000000000000001e-240 < x < 3.79999999999999985e-274Initial program 72.2%
Applied rewrites72.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6448.5
Applied rewrites48.5%
Taylor expanded in b around inf
Applied rewrites48.5%
if 3.79999999999999985e-274 < x < 5.3999999999999999e70Initial program 79.1%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.0
Applied rewrites47.0%
Taylor expanded in x around 0
Applied rewrites36.3%
if 5.3999999999999999e70 < x Initial program 77.7%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6477.4
Applied rewrites77.4%
Taylor expanded in a around inf
Applied rewrites55.6%
Final simplification46.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -6.5e+25)
(* (* a x) (- t))
(if (<= x -1.02e-56)
(* (* (- z) c) b)
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 3.8e-274)
(* (* i b) a)
(if (<= x 5.4e+70) (* (* (- j) i) y) (* (* (- a) t) x)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -6.5e+25) {
tmp = (a * x) * -t;
} else if (x <= -1.02e-56) {
tmp = (-z * c) * b;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 3.8e-274) {
tmp = (i * b) * a;
} else if (x <= 5.4e+70) {
tmp = (-j * i) * y;
} else {
tmp = (-a * t) * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (x <= (-6.5d+25)) then
tmp = (a * x) * -t
else if (x <= (-1.02d-56)) then
tmp = (-z * c) * b
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 3.8d-274) then
tmp = (i * b) * a
else if (x <= 5.4d+70) then
tmp = (-j * i) * y
else
tmp = (-a * t) * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -6.5e+25) {
tmp = (a * x) * -t;
} else if (x <= -1.02e-56) {
tmp = (-z * c) * b;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 3.8e-274) {
tmp = (i * b) * a;
} else if (x <= 5.4e+70) {
tmp = (-j * i) * y;
} else {
tmp = (-a * t) * x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -6.5e+25: tmp = (a * x) * -t elif x <= -1.02e-56: tmp = (-z * c) * b elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 3.8e-274: tmp = (i * b) * a elif x <= 5.4e+70: tmp = (-j * i) * y else: tmp = (-a * t) * x return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -6.5e+25) tmp = Float64(Float64(a * x) * Float64(-t)); elseif (x <= -1.02e-56) tmp = Float64(Float64(Float64(-z) * c) * b); elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 3.8e-274) tmp = Float64(Float64(i * b) * a); elseif (x <= 5.4e+70) tmp = Float64(Float64(Float64(-j) * i) * y); else tmp = Float64(Float64(Float64(-a) * t) * x); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -6.5e+25) tmp = (a * x) * -t; elseif (x <= -1.02e-56) tmp = (-z * c) * b; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 3.8e-274) tmp = (i * b) * a; elseif (x <= 5.4e+70) tmp = (-j * i) * y; else tmp = (-a * t) * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -6.5e+25], N[(N[(a * x), $MachinePrecision] * (-t)), $MachinePrecision], If[LessEqual[x, -1.02e-56], N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 3.8e-274], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 5.4e+70], N[(N[((-j) * i), $MachinePrecision] * y), $MachinePrecision], N[(N[((-a) * t), $MachinePrecision] * x), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6.5 \cdot 10^{+25}:\\
\;\;\;\;\left(a \cdot x\right) \cdot \left(-t\right)\\
\mathbf{elif}\;x \leq -1.02 \cdot 10^{-56}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{-274}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 5.4 \cdot 10^{+70}:\\
\;\;\;\;\left(\left(-j\right) \cdot i\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-a\right) \cdot t\right) \cdot x\\
\end{array}
\end{array}
if x < -6.50000000000000005e25Initial program 74.8%
Taylor expanded in t around -inf
Applied rewrites75.5%
Taylor expanded in a around inf
Applied rewrites59.1%
Taylor expanded in b around 0
Applied rewrites55.6%
if -6.50000000000000005e25 < x < -1.02e-56Initial program 58.9%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6467.6
Applied rewrites67.6%
Taylor expanded in c around inf
Applied rewrites59.8%
if -1.02e-56 < x < -4.1000000000000001e-240Initial program 79.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.3%
Taylor expanded in j around inf
Applied rewrites40.4%
Applied rewrites42.7%
if -4.1000000000000001e-240 < x < 3.79999999999999985e-274Initial program 72.2%
Applied rewrites72.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6448.5
Applied rewrites48.5%
Taylor expanded in b around inf
Applied rewrites48.5%
if 3.79999999999999985e-274 < x < 5.3999999999999999e70Initial program 79.1%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.0
Applied rewrites47.0%
Taylor expanded in x around 0
Applied rewrites36.3%
if 5.3999999999999999e70 < x Initial program 77.7%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6477.4
Applied rewrites77.4%
Taylor expanded in a around inf
Applied rewrites55.6%
Final simplification46.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- a) t) x)))
(if (<= x -6.5e+25)
t_1
(if (<= x -1.02e-56)
(* (* (- z) c) b)
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 3.8e-274)
(* (* i b) a)
(if (<= x 5.4e+70) (* (* (- 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 = (-a * t) * x;
double tmp;
if (x <= -6.5e+25) {
tmp = t_1;
} else if (x <= -1.02e-56) {
tmp = (-z * c) * b;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 3.8e-274) {
tmp = (i * b) * a;
} else if (x <= 5.4e+70) {
tmp = (-j * i) * y;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (-a * t) * x
if (x <= (-6.5d+25)) then
tmp = t_1
else if (x <= (-1.02d-56)) then
tmp = (-z * c) * b
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 3.8d-274) then
tmp = (i * b) * a
else if (x <= 5.4d+70) then
tmp = (-j * i) * y
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-a * t) * x;
double tmp;
if (x <= -6.5e+25) {
tmp = t_1;
} else if (x <= -1.02e-56) {
tmp = (-z * c) * b;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 3.8e-274) {
tmp = (i * b) * a;
} else if (x <= 5.4e+70) {
tmp = (-j * i) * y;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-a * t) * x tmp = 0 if x <= -6.5e+25: tmp = t_1 elif x <= -1.02e-56: tmp = (-z * c) * b elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 3.8e-274: tmp = (i * b) * a elif x <= 5.4e+70: tmp = (-j * i) * y else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-a) * t) * x) tmp = 0.0 if (x <= -6.5e+25) tmp = t_1; elseif (x <= -1.02e-56) tmp = Float64(Float64(Float64(-z) * c) * b); elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 3.8e-274) tmp = Float64(Float64(i * b) * a); elseif (x <= 5.4e+70) tmp = Float64(Float64(Float64(-j) * i) * y); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-a * t) * x; tmp = 0.0; if (x <= -6.5e+25) tmp = t_1; elseif (x <= -1.02e-56) tmp = (-z * c) * b; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 3.8e-274) tmp = (i * b) * a; elseif (x <= 5.4e+70) tmp = (-j * i) * y; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -6.5e+25], t$95$1, If[LessEqual[x, -1.02e-56], N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 3.8e-274], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 5.4e+70], N[(N[((-j) * i), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-a\right) \cdot t\right) \cdot x\\
\mathbf{if}\;x \leq -6.5 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.02 \cdot 10^{-56}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{-274}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 5.4 \cdot 10^{+70}:\\
\;\;\;\;\left(\left(-j\right) \cdot i\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -6.50000000000000005e25 or 5.3999999999999999e70 < x Initial program 75.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.8
Applied rewrites76.8%
Taylor expanded in a around inf
Applied rewrites55.5%
if -6.50000000000000005e25 < x < -1.02e-56Initial program 58.9%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6467.6
Applied rewrites67.6%
Taylor expanded in c around inf
Applied rewrites59.8%
if -1.02e-56 < x < -4.1000000000000001e-240Initial program 79.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.3%
Taylor expanded in j around inf
Applied rewrites40.4%
Applied rewrites42.7%
if -4.1000000000000001e-240 < x < 3.79999999999999985e-274Initial program 72.2%
Applied rewrites72.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6448.5
Applied rewrites48.5%
Taylor expanded in b around inf
Applied rewrites48.5%
if 3.79999999999999985e-274 < x < 5.3999999999999999e70Initial program 79.1%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.0
Applied rewrites47.0%
Taylor expanded in x around 0
Applied rewrites36.3%
Final simplification46.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- a) t) x)))
(if (<= x -6.5e+25)
t_1
(if (<= x -1.02e-56)
(* (* (- z) c) b)
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 4.4e-98)
(* (* i b) a)
(if (<= x 6.8e+70) (* (* (- j) y) i) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-a * t) * x;
double tmp;
if (x <= -6.5e+25) {
tmp = t_1;
} else if (x <= -1.02e-56) {
tmp = (-z * c) * b;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 4.4e-98) {
tmp = (i * b) * a;
} else if (x <= 6.8e+70) {
tmp = (-j * y) * 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 = (-a * t) * x
if (x <= (-6.5d+25)) then
tmp = t_1
else if (x <= (-1.02d-56)) then
tmp = (-z * c) * b
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 4.4d-98) then
tmp = (i * b) * a
else if (x <= 6.8d+70) then
tmp = (-j * y) * 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 = (-a * t) * x;
double tmp;
if (x <= -6.5e+25) {
tmp = t_1;
} else if (x <= -1.02e-56) {
tmp = (-z * c) * b;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 4.4e-98) {
tmp = (i * b) * a;
} else if (x <= 6.8e+70) {
tmp = (-j * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-a * t) * x tmp = 0 if x <= -6.5e+25: tmp = t_1 elif x <= -1.02e-56: tmp = (-z * c) * b elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 4.4e-98: tmp = (i * b) * a elif x <= 6.8e+70: tmp = (-j * y) * i else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-a) * t) * x) tmp = 0.0 if (x <= -6.5e+25) tmp = t_1; elseif (x <= -1.02e-56) tmp = Float64(Float64(Float64(-z) * c) * b); elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 4.4e-98) tmp = Float64(Float64(i * b) * a); elseif (x <= 6.8e+70) tmp = Float64(Float64(Float64(-j) * y) * i); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-a * t) * x; tmp = 0.0; if (x <= -6.5e+25) tmp = t_1; elseif (x <= -1.02e-56) tmp = (-z * c) * b; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 4.4e-98) tmp = (i * b) * a; elseif (x <= 6.8e+70) tmp = (-j * y) * 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[((-a) * t), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -6.5e+25], t$95$1, If[LessEqual[x, -1.02e-56], N[(N[((-z) * c), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 4.4e-98], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 6.8e+70], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-a\right) \cdot t\right) \cdot x\\
\mathbf{if}\;x \leq -6.5 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.02 \cdot 10^{-56}:\\
\;\;\;\;\left(\left(-z\right) \cdot c\right) \cdot b\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 4.4 \cdot 10^{-98}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 6.8 \cdot 10^{+70}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -6.50000000000000005e25 or 6.8000000000000002e70 < x Initial program 75.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.8
Applied rewrites76.8%
Taylor expanded in a around inf
Applied rewrites55.5%
if -6.50000000000000005e25 < x < -1.02e-56Initial program 58.9%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6467.6
Applied rewrites67.6%
Taylor expanded in c around inf
Applied rewrites59.8%
if -1.02e-56 < x < -4.1000000000000001e-240Initial program 79.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.3%
Taylor expanded in j around inf
Applied rewrites40.4%
Applied rewrites42.7%
if -4.1000000000000001e-240 < x < 4.39999999999999993e-98Initial program 82.8%
Applied rewrites82.7%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6441.5
Applied rewrites41.5%
Taylor expanded in b around inf
Applied rewrites41.2%
if 4.39999999999999993e-98 < x < 6.8000000000000002e70Initial program 70.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.5
Applied rewrites49.5%
Taylor expanded in x around 0
Applied rewrites29.5%
Final simplification45.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.7e+23)
t_1
(if (<= x -1.7e-283)
(* (fma (- b) z (* j t)) c)
(if (<= x 1.7e-49)
(* (fma (- c) z (* i a)) b)
(if (<= x 1.35e+95) (* (fma (- b) c (* y x)) z) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.7e+23) {
tmp = t_1;
} else if (x <= -1.7e-283) {
tmp = fma(-b, z, (j * t)) * c;
} else if (x <= 1.7e-49) {
tmp = fma(-c, z, (i * a)) * b;
} else if (x <= 1.35e+95) {
tmp = fma(-b, c, (y * x)) * z;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.7e+23) tmp = t_1; elseif (x <= -1.7e-283) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); elseif (x <= 1.7e-49) tmp = Float64(fma(Float64(-c), z, Float64(i * a)) * b); elseif (x <= 1.35e+95) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.7e+23], t$95$1, If[LessEqual[x, -1.7e-283], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[x, 1.7e-49], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 1.35e+95], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.7 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.7 \cdot 10^{-283}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{-49}:\\
\;\;\;\;\mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{elif}\;x \leq 1.35 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.6999999999999997e23 or 1.35e95 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -4.6999999999999997e23 < x < -1.6999999999999999e-283Initial program 73.3%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6453.2
Applied rewrites53.2%
if -1.6999999999999999e-283 < x < 1.70000000000000002e-49Initial program 83.7%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6453.6
Applied rewrites53.6%
if 1.70000000000000002e-49 < x < 1.35e95Initial program 72.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6452.3
Applied rewrites52.3%
Final simplification61.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.7e+23)
t_1
(if (<= x -3.1e-56)
(* (* (- b) c) z)
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 5.6e-62) (* (* i b) a) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.7e+23) {
tmp = t_1;
} else if (x <= -3.1e-56) {
tmp = (-b * c) * z;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 5.6e-62) {
tmp = (i * b) * a;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.7e+23) tmp = t_1; elseif (x <= -3.1e-56) tmp = Float64(Float64(Float64(-b) * c) * z); elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 5.6e-62) tmp = Float64(Float64(i * b) * a); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.7e+23], t$95$1, If[LessEqual[x, -3.1e-56], N[(N[((-b) * c), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 5.6e-62], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.7 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -3.1 \cdot 10^{-56}:\\
\;\;\;\;\left(\left(-b\right) \cdot c\right) \cdot z\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 5.6 \cdot 10^{-62}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.6999999999999997e23 or 5.60000000000000005e-62 < x Initial program 73.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6465.3
Applied rewrites65.3%
if -4.6999999999999997e23 < x < -3.09999999999999987e-56Initial program 58.9%
Applied rewrites67.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6418.8
Applied rewrites18.8%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/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-*.f6475.5
Applied rewrites75.5%
Taylor expanded in c around inf
Applied rewrites67.5%
if -3.09999999999999987e-56 < x < -4.1000000000000001e-240Initial program 79.0%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.3%
Taylor expanded in j around inf
Applied rewrites40.4%
Applied rewrites42.7%
if -4.1000000000000001e-240 < x < 5.60000000000000005e-62Initial program 82.8%
Applied rewrites82.7%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6438.9
Applied rewrites38.9%
Taylor expanded in b around inf
Applied rewrites38.7%
Final simplification54.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -6.8e+25)
t_1
(if (<= x 8e-81)
(fma (fma (- c) z (* i a)) b (* (* j c) t))
(if (<= x 2.85e+91) (* (fma (- j) i (* z x)) y) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -6.8e+25) {
tmp = t_1;
} else if (x <= 8e-81) {
tmp = fma(fma(-c, z, (i * a)), b, ((j * c) * t));
} else if (x <= 2.85e+91) {
tmp = fma(-j, i, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -6.8e+25) tmp = t_1; elseif (x <= 8e-81) tmp = fma(fma(Float64(-c), z, Float64(i * a)), b, Float64(Float64(j * c) * t)); elseif (x <= 2.85e+91) tmp = Float64(fma(Float64(-j), i, Float64(z * x)) * y); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -6.8e+25], t$95$1, If[LessEqual[x, 8e-81], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.85e+91], N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -6.8 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 8 \cdot 10^{-81}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-c, z, i \cdot a\right), b, \left(j \cdot c\right) \cdot t\right)\\
\mathbf{elif}\;x \leq 2.85 \cdot 10^{+91}:\\
\;\;\;\;\mathsf{fma}\left(-j, i, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -6.79999999999999967e25 or 2.84999999999999982e91 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -6.79999999999999967e25 < x < 7.9999999999999997e-81Initial program 79.5%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites65.7%
Taylor expanded in c around inf
Applied rewrites65.7%
if 7.9999999999999997e-81 < x < 2.84999999999999982e91Initial program 70.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.7
Applied rewrites51.7%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- a) t) x)))
(if (<= x -78000000.0)
t_1
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 4.4e-98)
(* (* i b) a)
(if (<= x 6.8e+70) (* (* (- j) y) i) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-a * t) * x;
double tmp;
if (x <= -78000000.0) {
tmp = t_1;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 4.4e-98) {
tmp = (i * b) * a;
} else if (x <= 6.8e+70) {
tmp = (-j * y) * 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 = (-a * t) * x
if (x <= (-78000000.0d0)) then
tmp = t_1
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 4.4d-98) then
tmp = (i * b) * a
else if (x <= 6.8d+70) then
tmp = (-j * y) * 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 = (-a * t) * x;
double tmp;
if (x <= -78000000.0) {
tmp = t_1;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 4.4e-98) {
tmp = (i * b) * a;
} else if (x <= 6.8e+70) {
tmp = (-j * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-a * t) * x tmp = 0 if x <= -78000000.0: tmp = t_1 elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 4.4e-98: tmp = (i * b) * a elif x <= 6.8e+70: tmp = (-j * y) * i else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-a) * t) * x) tmp = 0.0 if (x <= -78000000.0) tmp = t_1; elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 4.4e-98) tmp = Float64(Float64(i * b) * a); elseif (x <= 6.8e+70) tmp = Float64(Float64(Float64(-j) * y) * i); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-a * t) * x; tmp = 0.0; if (x <= -78000000.0) tmp = t_1; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 4.4e-98) tmp = (i * b) * a; elseif (x <= 6.8e+70) tmp = (-j * y) * 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[((-a) * t), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -78000000.0], t$95$1, If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 4.4e-98], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 6.8e+70], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-a\right) \cdot t\right) \cdot x\\
\mathbf{if}\;x \leq -78000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 4.4 \cdot 10^{-98}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 6.8 \cdot 10^{+70}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -7.8e7 or 6.8000000000000002e70 < x Initial program 74.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6472.4
Applied rewrites72.4%
Taylor expanded in a around inf
Applied rewrites52.3%
if -7.8e7 < x < -4.1000000000000001e-240Initial program 77.7%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.1%
Taylor expanded in j around inf
Applied rewrites39.8%
Applied rewrites41.9%
if -4.1000000000000001e-240 < x < 4.39999999999999993e-98Initial program 82.8%
Applied rewrites82.7%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6441.5
Applied rewrites41.5%
Taylor expanded in b around inf
Applied rewrites41.2%
if 4.39999999999999993e-98 < x < 6.8000000000000002e70Initial program 70.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.5
Applied rewrites49.5%
Taylor expanded in x around 0
Applied rewrites29.5%
Final simplification43.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- t) x) a)))
(if (<= x -78000000.0)
t_1
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 4.4e-98)
(* (* i b) a)
(if (<= x 2.02e+71) (* (* (- j) y) i) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-t * x) * a;
double tmp;
if (x <= -78000000.0) {
tmp = t_1;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 4.4e-98) {
tmp = (i * b) * a;
} else if (x <= 2.02e+71) {
tmp = (-j * y) * 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 = (-t * x) * a
if (x <= (-78000000.0d0)) then
tmp = t_1
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 4.4d-98) then
tmp = (i * b) * a
else if (x <= 2.02d+71) then
tmp = (-j * y) * 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 = (-t * x) * a;
double tmp;
if (x <= -78000000.0) {
tmp = t_1;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 4.4e-98) {
tmp = (i * b) * a;
} else if (x <= 2.02e+71) {
tmp = (-j * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-t * x) * a tmp = 0 if x <= -78000000.0: tmp = t_1 elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 4.4e-98: tmp = (i * b) * a elif x <= 2.02e+71: tmp = (-j * y) * i else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-t) * x) * a) tmp = 0.0 if (x <= -78000000.0) tmp = t_1; elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 4.4e-98) tmp = Float64(Float64(i * b) * a); elseif (x <= 2.02e+71) tmp = Float64(Float64(Float64(-j) * y) * i); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-t * x) * a; tmp = 0.0; if (x <= -78000000.0) tmp = t_1; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 4.4e-98) tmp = (i * b) * a; elseif (x <= 2.02e+71) tmp = (-j * y) * 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[((-t) * x), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[x, -78000000.0], t$95$1, If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 4.4e-98], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 2.02e+71], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-t\right) \cdot x\right) \cdot a\\
\mathbf{if}\;x \leq -78000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 4.4 \cdot 10^{-98}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 2.02 \cdot 10^{+71}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -7.8e7 or 2.01999999999999995e71 < x Initial program 74.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6472.4
Applied rewrites72.4%
Taylor expanded in a around inf
Applied rewrites49.3%
if -7.8e7 < x < -4.1000000000000001e-240Initial program 77.7%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.1%
Taylor expanded in j around inf
Applied rewrites39.8%
Applied rewrites41.9%
if -4.1000000000000001e-240 < x < 4.39999999999999993e-98Initial program 82.8%
Applied rewrites82.7%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6441.5
Applied rewrites41.5%
Taylor expanded in b around inf
Applied rewrites41.2%
if 4.39999999999999993e-98 < x < 2.01999999999999995e71Initial program 70.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.5
Applied rewrites49.5%
Taylor expanded in x around 0
Applied rewrites29.5%
Final simplification42.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- t) x) a)))
(if (<= x -78000000.0)
t_1
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 1.3e-34)
(* (* i b) a)
(if (<= x 3e+108) (* (* 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 = (-t * x) * a;
double tmp;
if (x <= -78000000.0) {
tmp = t_1;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 1.3e-34) {
tmp = (i * b) * a;
} else if (x <= 3e+108) {
tmp = (z * x) * y;
} 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 = (-t * x) * a
if (x <= (-78000000.0d0)) then
tmp = t_1
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 1.3d-34) then
tmp = (i * b) * a
else if (x <= 3d+108) then
tmp = (z * x) * y
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 = (-t * x) * a;
double tmp;
if (x <= -78000000.0) {
tmp = t_1;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 1.3e-34) {
tmp = (i * b) * a;
} else if (x <= 3e+108) {
tmp = (z * x) * y;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-t * x) * a tmp = 0 if x <= -78000000.0: tmp = t_1 elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 1.3e-34: tmp = (i * b) * a elif x <= 3e+108: tmp = (z * x) * y else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-t) * x) * a) tmp = 0.0 if (x <= -78000000.0) tmp = t_1; elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 1.3e-34) tmp = Float64(Float64(i * b) * a); elseif (x <= 3e+108) tmp = Float64(Float64(z * x) * y); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-t * x) * a; tmp = 0.0; if (x <= -78000000.0) tmp = t_1; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 1.3e-34) tmp = (i * b) * a; elseif (x <= 3e+108) tmp = (z * x) * y; 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[((-t) * x), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[x, -78000000.0], t$95$1, If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 1.3e-34], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 3e+108], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-t\right) \cdot x\right) \cdot a\\
\mathbf{if}\;x \leq -78000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{-34}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 3 \cdot 10^{+108}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -7.8e7 or 2.99999999999999984e108 < x Initial program 72.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6473.1
Applied rewrites73.1%
Taylor expanded in a around inf
Applied rewrites50.8%
if -7.8e7 < x < -4.1000000000000001e-240Initial program 77.7%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.1%
Taylor expanded in j around inf
Applied rewrites39.8%
Applied rewrites41.9%
if -4.1000000000000001e-240 < x < 1.3e-34Initial program 79.3%
Applied rewrites79.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6440.6
Applied rewrites40.6%
Taylor expanded in b around inf
Applied rewrites37.9%
if 1.3e-34 < x < 2.99999999999999984e108Initial program 77.5%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.7
Applied rewrites51.7%
Taylor expanded in x around inf
Applied rewrites29.1%
Final simplification42.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -4.7e+23)
t_1
(if (<= x 2.95e+91) (* (fma (- b) z (* j t)) c) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -4.7e+23) {
tmp = t_1;
} else if (x <= 2.95e+91) {
tmp = fma(-b, z, (j * t)) * c;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -4.7e+23) tmp = t_1; elseif (x <= 2.95e+91) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4.7e+23], t$95$1, If[LessEqual[x, 2.95e+91], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4.7 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2.95 \cdot 10^{+91}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.6999999999999997e23 or 2.9500000000000001e91 < x Initial program 75.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6478.3
Applied rewrites78.3%
if -4.6999999999999997e23 < x < 2.9500000000000001e91Initial program 77.1%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6443.9
Applied rewrites43.9%
Final simplification55.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -78000000.0)
(* (* y x) z)
(if (<= x -4.1e-240)
(* (* j c) t)
(if (<= x 1.3e-34) (* (* i b) a) (* (* 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 (x <= -78000000.0) {
tmp = (y * x) * z;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 1.3e-34) {
tmp = (i * b) * a;
} 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 (x <= (-78000000.0d0)) then
tmp = (y * x) * z
else if (x <= (-4.1d-240)) then
tmp = (j * c) * t
else if (x <= 1.3d-34) then
tmp = (i * b) * a
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 (x <= -78000000.0) {
tmp = (y * x) * z;
} else if (x <= -4.1e-240) {
tmp = (j * c) * t;
} else if (x <= 1.3e-34) {
tmp = (i * b) * a;
} else {
tmp = (z * x) * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -78000000.0: tmp = (y * x) * z elif x <= -4.1e-240: tmp = (j * c) * t elif x <= 1.3e-34: tmp = (i * b) * a else: tmp = (z * x) * y return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -78000000.0) tmp = Float64(Float64(y * x) * z); elseif (x <= -4.1e-240) tmp = Float64(Float64(j * c) * t); elseif (x <= 1.3e-34) tmp = Float64(Float64(i * b) * a); 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 (x <= -78000000.0) tmp = (y * x) * z; elseif (x <= -4.1e-240) tmp = (j * c) * t; elseif (x <= 1.3e-34) tmp = (i * b) * a; else tmp = (z * x) * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -78000000.0], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[x, -4.1e-240], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[x, 1.3e-34], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -78000000:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{elif}\;x \leq -4.1 \cdot 10^{-240}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{-34}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\end{array}
\end{array}
if x < -7.8e7Initial program 72.6%
Applied rewrites78.7%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6452.2
Applied rewrites52.2%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/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-*.f6442.3
Applied rewrites42.3%
Taylor expanded in c around 0
Applied rewrites32.1%
if -7.8e7 < x < -4.1000000000000001e-240Initial program 77.7%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites69.1%
Taylor expanded in j around inf
Applied rewrites39.8%
Applied rewrites41.9%
if -4.1000000000000001e-240 < x < 1.3e-34Initial program 79.3%
Applied rewrites79.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6440.6
Applied rewrites40.6%
Taylor expanded in b around inf
Applied rewrites37.9%
if 1.3e-34 < x Initial program 75.8%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6446.6
Applied rewrites46.6%
Taylor expanded in x around inf
Applied rewrites33.5%
Final simplification36.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* i a) b)))
(if (<= i -7400000000.0)
t_1
(if (<= i 1.05e-289)
(* (* y x) z)
(if (<= i 2.3e+54) (* (* c t) j) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * a) * b;
double tmp;
if (i <= -7400000000.0) {
tmp = t_1;
} else if (i <= 1.05e-289) {
tmp = (y * x) * z;
} else if (i <= 2.3e+54) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (i * a) * b
if (i <= (-7400000000.0d0)) then
tmp = t_1
else if (i <= 1.05d-289) then
tmp = (y * x) * z
else if (i <= 2.3d+54) then
tmp = (c * t) * j
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * a) * b;
double tmp;
if (i <= -7400000000.0) {
tmp = t_1;
} else if (i <= 1.05e-289) {
tmp = (y * x) * z;
} else if (i <= 2.3e+54) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * a) * b tmp = 0 if i <= -7400000000.0: tmp = t_1 elif i <= 1.05e-289: tmp = (y * x) * z elif i <= 2.3e+54: tmp = (c * t) * j else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * a) * b) tmp = 0.0 if (i <= -7400000000.0) tmp = t_1; elseif (i <= 1.05e-289) tmp = Float64(Float64(y * x) * z); elseif (i <= 2.3e+54) tmp = Float64(Float64(c * t) * j); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (i * a) * b; tmp = 0.0; if (i <= -7400000000.0) tmp = t_1; elseif (i <= 1.05e-289) tmp = (y * x) * z; elseif (i <= 2.3e+54) tmp = (c * t) * j; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(i * a), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[i, -7400000000.0], t$95$1, If[LessEqual[i, 1.05e-289], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[i, 2.3e+54], N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot a\right) \cdot b\\
\mathbf{if}\;i \leq -7400000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 1.05 \cdot 10^{-289}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{elif}\;i \leq 2.3 \cdot 10^{+54}:\\
\;\;\;\;\left(c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -7.4e9 or 2.29999999999999994e54 < i Initial program 69.8%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6450.8
Applied rewrites50.8%
Taylor expanded in c around 0
Applied rewrites39.0%
if -7.4e9 < i < 1.0499999999999999e-289Initial program 82.2%
Applied rewrites82.1%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6442.2
Applied rewrites42.2%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/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-*.f6443.5
Applied rewrites43.5%
Taylor expanded in c around 0
Applied rewrites26.8%
if 1.0499999999999999e-289 < i < 2.29999999999999994e54Initial program 81.4%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites68.1%
Taylor expanded in j around inf
Applied rewrites39.7%
Applied rewrites39.8%
Final simplification35.5%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* i a) b))) (if (<= i -400000000.0) t_1 (if (<= i 2.3e+54) (* (* c t) j) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * a) * b;
double tmp;
if (i <= -400000000.0) {
tmp = t_1;
} else if (i <= 2.3e+54) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (i * a) * b
if (i <= (-400000000.0d0)) then
tmp = t_1
else if (i <= 2.3d+54) then
tmp = (c * t) * j
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * a) * b;
double tmp;
if (i <= -400000000.0) {
tmp = t_1;
} else if (i <= 2.3e+54) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * a) * b tmp = 0 if i <= -400000000.0: tmp = t_1 elif i <= 2.3e+54: tmp = (c * t) * j else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * a) * b) tmp = 0.0 if (i <= -400000000.0) tmp = t_1; elseif (i <= 2.3e+54) tmp = Float64(Float64(c * t) * j); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (i * a) * b; tmp = 0.0; if (i <= -400000000.0) tmp = t_1; elseif (i <= 2.3e+54) tmp = (c * t) * j; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(i * a), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[i, -400000000.0], t$95$1, If[LessEqual[i, 2.3e+54], N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot a\right) \cdot b\\
\mathbf{if}\;i \leq -400000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 2.3 \cdot 10^{+54}:\\
\;\;\;\;\left(c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -4e8 or 2.29999999999999994e54 < i Initial program 69.8%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6450.8
Applied rewrites50.8%
Taylor expanded in c around 0
Applied rewrites39.0%
if -4e8 < i < 2.29999999999999994e54Initial program 81.8%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites66.8%
Taylor expanded in j around inf
Applied rewrites26.5%
Applied rewrites29.2%
Final simplification33.6%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* z y) x))) (if (<= y -4.8e+81) t_1 (if (<= y 2.25e-22) (* (* c t) j) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (z * y) * x;
double tmp;
if (y <= -4.8e+81) {
tmp = t_1;
} else if (y <= 2.25e-22) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (z * y) * x
if (y <= (-4.8d+81)) then
tmp = t_1
else if (y <= 2.25d-22) then
tmp = (c * t) * j
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (z * y) * x;
double tmp;
if (y <= -4.8e+81) {
tmp = t_1;
} else if (y <= 2.25e-22) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (z * y) * x tmp = 0 if y <= -4.8e+81: tmp = t_1 elif y <= 2.25e-22: tmp = (c * t) * j else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(z * y) * x) tmp = 0.0 if (y <= -4.8e+81) tmp = t_1; elseif (y <= 2.25e-22) tmp = Float64(Float64(c * t) * j); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (z * y) * x; tmp = 0.0; if (y <= -4.8e+81) tmp = t_1; elseif (y <= 2.25e-22) tmp = (c * t) * j; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[y, -4.8e+81], t$95$1, If[LessEqual[y, 2.25e-22], N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot y\right) \cdot x\\
\mathbf{if}\;y \leq -4.8 \cdot 10^{+81}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.25 \cdot 10^{-22}:\\
\;\;\;\;\left(c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -4.79999999999999979e81 or 2.24999999999999993e-22 < y Initial program 71.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6444.6
Applied rewrites44.6%
Taylor expanded in a around 0
Applied rewrites34.6%
if -4.79999999999999979e81 < y < 2.24999999999999993e-22Initial program 79.9%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites74.7%
Taylor expanded in j around inf
Applied rewrites28.4%
Applied rewrites30.4%
(FPCore (x y z t a b c i j) :precision binary64 (* (* c t) j))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (c * t) * j;
}
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 = (c * t) * j
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 (c * t) * j;
}
def code(x, y, z, t, a, b, c, i, j): return (c * t) * j
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(c * t) * j) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (c * t) * j; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision]
\begin{array}{l}
\\
\left(c \cdot t\right) \cdot j
\end{array}
Initial program 76.4%
Taylor expanded in y around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites61.3%
Taylor expanded in j around inf
Applied rewrites21.3%
Applied rewrites23.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024255
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:alt
(! :herbie-platform default (if (< t -1015122364899489/125000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -942510763643697/2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (if (< t -238547917063487/3125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 10535888557455487/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))