
(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 25 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 (- z) c (* i a)) b))))
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(-z, c, (i * a)) * b;
}
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(Float64(-z), c, Float64(i * a)) * b); 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[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $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(-z, c, i \cdot a\right) \cdot b\\
\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 92.3%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.1
Applied rewrites54.1%
Final simplification85.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- z) c (* i a)) b (* (fma (- i) j (* z x)) y))))
(if (<= t -3.25e+186)
(+ (* (* j t) c) (* (fma (- x) t (* i b)) a))
(if (<= t -1.35e-6)
t_1
(if (<= t -7e-101)
(fma (fma (- z) b (* j t)) c (* (fma (- t) a (* z y)) x))
(if (<= t 8e+72) t_1 (* (fma (- x) a (* j c)) t)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(fma(-z, c, (i * a)), b, (fma(-i, j, (z * x)) * y));
double tmp;
if (t <= -3.25e+186) {
tmp = ((j * t) * c) + (fma(-x, t, (i * b)) * a);
} else if (t <= -1.35e-6) {
tmp = t_1;
} else if (t <= -7e-101) {
tmp = fma(fma(-z, b, (j * t)), c, (fma(-t, a, (z * y)) * x));
} else if (t <= 8e+72) {
tmp = t_1;
} else {
tmp = fma(-x, a, (j * c)) * t;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-z), c, Float64(i * a)), b, Float64(fma(Float64(-i), j, Float64(z * x)) * y)) tmp = 0.0 if (t <= -3.25e+186) tmp = Float64(Float64(Float64(j * t) * c) + Float64(fma(Float64(-x), t, Float64(i * b)) * a)); elseif (t <= -1.35e-6) tmp = t_1; elseif (t <= -7e-101) tmp = fma(fma(Float64(-z), b, Float64(j * t)), c, Float64(fma(Float64(-t), a, Float64(z * y)) * x)); elseif (t <= 8e+72) tmp = t_1; else tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.25e+186], N[(N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision] + N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.35e-6], t$95$1, If[LessEqual[t, -7e-101], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e+72], t$95$1, N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-z, c, i \cdot a\right), b, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)\\
\mathbf{if}\;t \leq -3.25 \cdot 10^{+186}:\\
\;\;\;\;\left(j \cdot t\right) \cdot c + \mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{elif}\;t \leq -1.35 \cdot 10^{-6}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -7 \cdot 10^{-101}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot t\right), c, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;t \leq 8 \cdot 10^{+72}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\end{array}
\end{array}
if t < -3.2499999999999998e186Initial program 57.3%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6457.3
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6457.3
Applied rewrites57.3%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6457.2
Applied rewrites57.2%
Taylor expanded in z around 0
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
*-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-*.f6478.4
Applied rewrites78.4%
if -3.2499999999999998e186 < t < -1.34999999999999999e-6 or -6.99999999999999989e-101 < t < 7.99999999999999955e72Initial program 81.8%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites75.7%
if -1.34999999999999999e-6 < t < -6.99999999999999989e-101Initial program 71.0%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites85.6%
if 7.99999999999999955e72 < t Initial program 69.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6480.7
Applied rewrites80.7%
Final simplification77.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* (* z x) y) (* (- (* c t) (* i y)) j)))
(t_2 (* (fma (- z) c (* i a)) b)))
(if (<= b -3e+92)
t_2
(if (<= b -7.2e-151)
t_1
(if (<= b 1.35e-204)
(* (* (- y (/ (* a t) z)) z) x)
(if (<= b 1.18e+83) 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 = ((z * x) * y) + (((c * t) - (i * y)) * j);
double t_2 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -3e+92) {
tmp = t_2;
} else if (b <= -7.2e-151) {
tmp = t_1;
} else if (b <= 1.35e-204) {
tmp = ((y - ((a * t) / z)) * z) * x;
} else if (b <= 1.18e+83) {
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(z * x) * y) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)) t_2 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -3e+92) tmp = t_2; elseif (b <= -7.2e-151) tmp = t_1; elseif (b <= 1.35e-204) tmp = Float64(Float64(Float64(y - Float64(Float64(a * t) / z)) * z) * x); elseif (b <= 1.18e+83) 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[(N[(z * x), $MachinePrecision] * y), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -3e+92], t$95$2, If[LessEqual[b, -7.2e-151], t$95$1, If[LessEqual[b, 1.35e-204], N[(N[(N[(y - N[(N[(a * t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 1.18e+83], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot x\right) \cdot y + \left(c \cdot t - i \cdot y\right) \cdot j\\
t_2 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -3 \cdot 10^{+92}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -7.2 \cdot 10^{-151}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.35 \cdot 10^{-204}:\\
\;\;\;\;\left(\left(y - \frac{a \cdot t}{z}\right) \cdot z\right) \cdot x\\
\mathbf{elif}\;b \leq 1.18 \cdot 10^{+83}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -3.00000000000000013e92 or 1.1799999999999999e83 < b Initial program 74.5%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6477.3
Applied rewrites77.3%
if -3.00000000000000013e92 < b < -7.20000000000000064e-151 or 1.34999999999999996e-204 < b < 1.1799999999999999e83Initial program 76.0%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6468.3
Applied rewrites68.3%
if -7.20000000000000064e-151 < b < 1.34999999999999996e-204Initial program 79.0%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6479.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6479.0
Applied rewrites79.0%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6469.4
Applied rewrites69.4%
Taylor expanded in z around inf
Applied rewrites69.5%
Taylor expanded in x around inf
Applied rewrites73.5%
Final simplification72.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (- z) c (* i a))))
(if (<= b -5.4e+87)
(fma t_1 b (* (fma (- i) j (* z x)) y))
(if (<= b 2.4e+84)
(fma (fma (- t) a (* z y)) x (* (fma (- i) y (* c t)) j))
(* t_1 b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-z, c, (i * a));
double tmp;
if (b <= -5.4e+87) {
tmp = fma(t_1, b, (fma(-i, j, (z * x)) * y));
} else if (b <= 2.4e+84) {
tmp = fma(fma(-t, a, (z * y)), x, (fma(-i, y, (c * t)) * j));
} else {
tmp = t_1 * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(-z), c, Float64(i * a)) tmp = 0.0 if (b <= -5.4e+87) tmp = fma(t_1, b, Float64(fma(Float64(-i), j, Float64(z * x)) * y)); elseif (b <= 2.4e+84) tmp = fma(fma(Float64(-t), a, Float64(z * y)), x, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); else tmp = Float64(t_1 * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5.4e+87], N[(t$95$1 * b + N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.4e+84], N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right)\\
\mathbf{if}\;b \leq -5.4 \cdot 10^{+87}:\\
\;\;\;\;\mathsf{fma}\left(t\_1, b, \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\right)\\
\mathbf{elif}\;b \leq 2.4 \cdot 10^{+84}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-t, a, z \cdot y\right), x, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 \cdot b\\
\end{array}
\end{array}
if b < -5.40000000000000013e87Initial program 76.3%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites78.2%
if -5.40000000000000013e87 < b < 2.4e84Initial program 76.9%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6476.9
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6476.9
Applied rewrites76.9%
Taylor expanded in b around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
*-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-*.f6480.8
Applied rewrites80.8%
if 2.4e84 < b Initial program 72.5%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6479.5
Applied rewrites79.5%
Final simplification80.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -8.5e+198)
t_1
(if (<= b 1.18e+83)
(fma (fma (- y) j (* b a)) i (* (fma (- t) a (* z y)) x))
t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -8.5e+198) {
tmp = t_1;
} else if (b <= 1.18e+83) {
tmp = fma(fma(-y, j, (b * a)), i, (fma(-t, a, (z * y)) * x));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -8.5e+198) tmp = t_1; elseif (b <= 1.18e+83) tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(fma(Float64(-t), a, Float64(z * y)) * x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -8.5e+198], t$95$1, If[LessEqual[b, 1.18e+83], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -8.5 \cdot 10^{+198}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.18 \cdot 10^{+83}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -8.5000000000000001e198 or 1.1799999999999999e83 < b Initial program 74.3%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6481.4
Applied rewrites81.4%
if -8.5000000000000001e198 < b < 1.1799999999999999e83Initial program 76.8%
Taylor expanded in c around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
cancel-sign-subN/A
mul-1-negN/A
associate-*r*N/A
+-commutativeN/A
Applied rewrites69.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -3.6e-63)
(+ (* (* j t) c) (* (fma (- x) t (* i b)) a))
(if (<= a 9.5e-112)
(fma (fma (- i) y (* c t)) j (* (* (- z) b) c))
(if (<= a 5.8e+196)
(fma (* b a) i (* (fma (- t) a (* z y)) x))
(* (fma (- z) c (* i a)) b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -3.6e-63) {
tmp = ((j * t) * c) + (fma(-x, t, (i * b)) * a);
} else if (a <= 9.5e-112) {
tmp = fma(fma(-i, y, (c * t)), j, ((-z * b) * c));
} else if (a <= 5.8e+196) {
tmp = fma((b * a), i, (fma(-t, a, (z * y)) * x));
} else {
tmp = fma(-z, c, (i * a)) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -3.6e-63) tmp = Float64(Float64(Float64(j * t) * c) + Float64(fma(Float64(-x), t, Float64(i * b)) * a)); elseif (a <= 9.5e-112) tmp = fma(fma(Float64(-i), y, Float64(c * t)), j, Float64(Float64(Float64(-z) * b) * c)); elseif (a <= 5.8e+196) tmp = fma(Float64(b * a), i, Float64(fma(Float64(-t), a, Float64(z * y)) * x)); else tmp = Float64(fma(Float64(-z), c, Float64(i * a)) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -3.6e-63], N[(N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision] + N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 9.5e-112], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j + N[(N[((-z) * b), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5.8e+196], N[(N[(b * a), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.6 \cdot 10^{-63}:\\
\;\;\;\;\left(j \cdot t\right) \cdot c + \mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{elif}\;a \leq 9.5 \cdot 10^{-112}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-i, y, c \cdot t\right), j, \left(\left(-z\right) \cdot b\right) \cdot c\right)\\
\mathbf{elif}\;a \leq 5.8 \cdot 10^{+196}:\\
\;\;\;\;\mathsf{fma}\left(b \cdot a, i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\end{array}
\end{array}
if a < -3.60000000000000008e-63Initial program 71.3%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6471.3
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6471.3
Applied rewrites71.3%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6471.3
Applied rewrites71.3%
Taylor expanded in z around 0
associate-*r*N/A
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
*-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-*.f6470.1
Applied rewrites70.1%
if -3.60000000000000008e-63 < a < 9.50000000000000056e-112Initial program 78.9%
Taylor expanded in c around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6471.4
Applied rewrites71.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6472.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6472.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6472.4
Applied rewrites72.4%
if 9.50000000000000056e-112 < a < 5.8e196Initial program 84.9%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6484.9
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6484.9
Applied rewrites84.9%
Taylor expanded in c around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
cancel-sign-subN/A
mul-1-negN/A
associate-*r*N/A
+-commutativeN/A
Applied rewrites82.0%
Taylor expanded in y around 0
Applied rewrites78.7%
if 5.8e196 < a Initial program 52.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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6468.3
Applied rewrites68.3%
Final simplification72.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) j (* z x)) y)) (t_2 (* (fma (- x) a (* j c)) t)))
(if (<= t -1e+185)
t_2
(if (<= t -6.5e+89)
t_1
(if (<= t 2.1e-301)
(* (fma y x (* (- b) c)) z)
(if (<= t 360000000.0) 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(-i, j, (z * x)) * y;
double t_2 = fma(-x, a, (j * c)) * t;
double tmp;
if (t <= -1e+185) {
tmp = t_2;
} else if (t <= -6.5e+89) {
tmp = t_1;
} else if (t <= 2.1e-301) {
tmp = fma(y, x, (-b * c)) * z;
} else if (t <= 360000000.0) {
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(-i), j, Float64(z * x)) * y) t_2 = Float64(fma(Float64(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -1e+185) tmp = t_2; elseif (t <= -6.5e+89) tmp = t_1; elseif (t <= 2.1e-301) tmp = Float64(fma(y, x, Float64(Float64(-b) * c)) * z); elseif (t <= 360000000.0) 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[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -1e+185], t$95$2, If[LessEqual[t, -6.5e+89], t$95$1, If[LessEqual[t, 2.1e-301], N[(N[(y * x + N[((-b) * c), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 360000000.0], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
t_2 := \mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{if}\;t \leq -1 \cdot 10^{+185}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -6.5 \cdot 10^{+89}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{-301}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \left(-b\right) \cdot c\right) \cdot z\\
\mathbf{elif}\;t \leq 360000000:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -9.9999999999999998e184 or 3.6e8 < t Initial program 66.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.8
Applied rewrites70.8%
if -9.9999999999999998e184 < t < -6.4999999999999996e89 or 2.0999999999999999e-301 < t < 3.6e8Initial program 81.8%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6453.3
Applied rewrites53.3%
if -6.4999999999999996e89 < t < 2.0999999999999999e-301Initial program 80.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.1
Applied rewrites50.1%
Applied rewrites50.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -1.65e-19)
t_1
(if (<= b 1.8e+78) (fma (* b a) i (* (fma (- t) a (* z y)) x)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -1.65e-19) {
tmp = t_1;
} else if (b <= 1.8e+78) {
tmp = fma((b * a), i, (fma(-t, a, (z * y)) * x));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -1.65e-19) tmp = t_1; elseif (b <= 1.8e+78) tmp = fma(Float64(b * a), i, Float64(fma(Float64(-t), a, Float64(z * y)) * x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -1.65e-19], t$95$1, If[LessEqual[b, 1.8e+78], N[(N[(b * a), $MachinePrecision] * i + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -1.65 \cdot 10^{-19}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.8 \cdot 10^{+78}:\\
\;\;\;\;\mathsf{fma}\left(b \cdot a, i, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.6499999999999999e-19 or 1.8000000000000001e78 < b Initial program 75.0%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.3
Applied rewrites70.3%
if -1.6499999999999999e-19 < b < 1.8000000000000001e78Initial program 77.0%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6477.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6477.0
Applied rewrites77.0%
Taylor expanded in c around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
cancel-sign-subN/A
mul-1-negN/A
associate-*r*N/A
+-commutativeN/A
Applied rewrites72.7%
Taylor expanded in y around 0
Applied rewrites60.3%
Final simplification65.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -1e-59)
t_1
(if (<= b 7e-204)
(* (* (- y (/ (* a t) z)) z) x)
(if (<= b 9.6e+82) (* (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(-z, c, (i * a)) * b;
double tmp;
if (b <= -1e-59) {
tmp = t_1;
} else if (b <= 7e-204) {
tmp = ((y - ((a * t) / z)) * z) * x;
} else if (b <= 9.6e+82) {
tmp = fma(-i, y, (c * t)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -1e-59) tmp = t_1; elseif (b <= 7e-204) tmp = Float64(Float64(Float64(y - Float64(Float64(a * t) / z)) * z) * x); elseif (b <= 9.6e+82) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -1e-59], t$95$1, If[LessEqual[b, 7e-204], N[(N[(N[(y - N[(N[(a * t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 9.6e+82], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -1 \cdot 10^{-59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 7 \cdot 10^{-204}:\\
\;\;\;\;\left(\left(y - \frac{a \cdot t}{z}\right) \cdot z\right) \cdot x\\
\mathbf{elif}\;b \leq 9.6 \cdot 10^{+82}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1e-59 or 9.59999999999999992e82 < b Initial program 74.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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.0
Applied rewrites70.0%
if -1e-59 < b < 7.00000000000000054e-204Initial program 76.4%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6476.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6476.4
Applied rewrites76.4%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6468.4
Applied rewrites68.4%
Taylor expanded in z around inf
Applied rewrites77.4%
Taylor expanded in x around inf
Applied rewrites67.3%
if 7.00000000000000054e-204 < b < 9.59999999999999992e82Initial program 78.4%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6478.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6478.4
Applied rewrites78.4%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.1
Applied rewrites62.1%
Taylor expanded in z around inf
Applied rewrites67.0%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6453.9
Applied rewrites53.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= b -1.62e-168)
(* (fma y x (* (- b) c)) z)
(if (<= b -5.4e-272)
(* (* (- x) t) a)
(if (<= b 1.18e+83)
(* (fma (- i) j (* z x)) y)
(if (<= b 2.6e+239) (* (* (- z) b) c) (* (* i b) a))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -1.62e-168) {
tmp = fma(y, x, (-b * c)) * z;
} else if (b <= -5.4e-272) {
tmp = (-x * t) * a;
} else if (b <= 1.18e+83) {
tmp = fma(-i, j, (z * x)) * y;
} else if (b <= 2.6e+239) {
tmp = (-z * b) * c;
} else {
tmp = (i * b) * a;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -1.62e-168) tmp = Float64(fma(y, x, Float64(Float64(-b) * c)) * z); elseif (b <= -5.4e-272) tmp = Float64(Float64(Float64(-x) * t) * a); elseif (b <= 1.18e+83) tmp = Float64(fma(Float64(-i), j, Float64(z * x)) * y); elseif (b <= 2.6e+239) tmp = Float64(Float64(Float64(-z) * b) * c); else tmp = Float64(Float64(i * b) * a); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -1.62e-168], N[(N[(y * x + N[((-b) * c), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[b, -5.4e-272], N[(N[((-x) * t), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[b, 1.18e+83], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[b, 2.6e+239], N[(N[((-z) * b), $MachinePrecision] * c), $MachinePrecision], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.62 \cdot 10^{-168}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \left(-b\right) \cdot c\right) \cdot z\\
\mathbf{elif}\;b \leq -5.4 \cdot 10^{-272}:\\
\;\;\;\;\left(\left(-x\right) \cdot t\right) \cdot a\\
\mathbf{elif}\;b \leq 1.18 \cdot 10^{+83}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{elif}\;b \leq 2.6 \cdot 10^{+239}:\\
\;\;\;\;\left(\left(-z\right) \cdot b\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\end{array}
\end{array}
if b < -1.6200000000000001e-168Initial program 74.1%
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
*-commutativeN/A
lower-*.f6450.9
Applied rewrites50.9%
Applied rewrites51.9%
if -1.6200000000000001e-168 < b < -5.39999999999999985e-272Initial program 90.8%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6490.8
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6490.8
Applied rewrites90.8%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6467.9
Applied rewrites67.9%
Taylor expanded in x around inf
Applied rewrites63.3%
if -5.39999999999999985e-272 < b < 1.1799999999999999e83Initial program 76.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.7
Applied rewrites49.7%
if 1.1799999999999999e83 < b < 2.6000000000000002e239Initial program 80.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
*-commutativeN/A
lower-*.f6436.0
Applied rewrites36.0%
Taylor expanded in x around 0
Applied rewrites47.3%
if 2.6000000000000002e239 < b Initial program 59.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-*.f6467.6
Applied rewrites67.6%
Taylor expanded in y around 0
Applied rewrites74.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* b a) i)))
(if (<= b -1.1e+203)
(* (* (- b) c) z)
(if (<= b -1.2e+81)
t_1
(if (<= b -9.5e-164)
(* (* y x) z)
(if (<= b 2.1e-21) (* (* (- x) t) 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 = (b * a) * i;
double tmp;
if (b <= -1.1e+203) {
tmp = (-b * c) * z;
} else if (b <= -1.2e+81) {
tmp = t_1;
} else if (b <= -9.5e-164) {
tmp = (y * x) * z;
} else if (b <= 2.1e-21) {
tmp = (-x * t) * a;
} 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 = (b * a) * i
if (b <= (-1.1d+203)) then
tmp = (-b * c) * z
else if (b <= (-1.2d+81)) then
tmp = t_1
else if (b <= (-9.5d-164)) then
tmp = (y * x) * z
else if (b <= 2.1d-21) then
tmp = (-x * t) * a
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 = (b * a) * i;
double tmp;
if (b <= -1.1e+203) {
tmp = (-b * c) * z;
} else if (b <= -1.2e+81) {
tmp = t_1;
} else if (b <= -9.5e-164) {
tmp = (y * x) * z;
} else if (b <= 2.1e-21) {
tmp = (-x * t) * a;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (b * a) * i tmp = 0 if b <= -1.1e+203: tmp = (-b * c) * z elif b <= -1.2e+81: tmp = t_1 elif b <= -9.5e-164: tmp = (y * x) * z elif b <= 2.1e-21: tmp = (-x * t) * a else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(b * a) * i) tmp = 0.0 if (b <= -1.1e+203) tmp = Float64(Float64(Float64(-b) * c) * z); elseif (b <= -1.2e+81) tmp = t_1; elseif (b <= -9.5e-164) tmp = Float64(Float64(y * x) * z); elseif (b <= 2.1e-21) tmp = Float64(Float64(Float64(-x) * t) * a); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (b * a) * i; tmp = 0.0; if (b <= -1.1e+203) tmp = (-b * c) * z; elseif (b <= -1.2e+81) tmp = t_1; elseif (b <= -9.5e-164) tmp = (y * x) * z; elseif (b <= 2.1e-21) tmp = (-x * t) * a; 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[(b * a), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[b, -1.1e+203], N[(N[((-b) * c), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[b, -1.2e+81], t$95$1, If[LessEqual[b, -9.5e-164], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[b, 2.1e-21], N[(N[((-x) * t), $MachinePrecision] * a), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot a\right) \cdot i\\
\mathbf{if}\;b \leq -1.1 \cdot 10^{+203}:\\
\;\;\;\;\left(\left(-b\right) \cdot c\right) \cdot z\\
\mathbf{elif}\;b \leq -1.2 \cdot 10^{+81}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -9.5 \cdot 10^{-164}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{elif}\;b \leq 2.1 \cdot 10^{-21}:\\
\;\;\;\;\left(\left(-x\right) \cdot t\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.10000000000000002e203Initial program 77.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
*-commutativeN/A
lower-*.f6467.6
Applied rewrites67.6%
Taylor expanded in x around 0
Applied rewrites63.6%
if -1.10000000000000002e203 < b < -1.19999999999999995e81 or 2.10000000000000013e-21 < b Initial program 73.3%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.5
Applied rewrites52.5%
Taylor expanded in y around 0
Applied rewrites41.8%
if -1.19999999999999995e81 < b < -9.5000000000000001e-164Initial program 73.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
*-commutativeN/A
lower-*.f6450.5
Applied rewrites50.5%
Taylor expanded in x around inf
Applied rewrites35.7%
if -9.5000000000000001e-164 < b < 2.10000000000000013e-21Initial program 79.5%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6479.5
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6479.5
Applied rewrites79.5%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6455.9
Applied rewrites55.9%
Taylor expanded in x around inf
Applied rewrites40.5%
Final simplification43.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -1e-59)
t_1
(if (<= b 7e-204)
(* (fma (- t) a (* z y)) x)
(if (<= b 9.6e+82) (* (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(-z, c, (i * a)) * b;
double tmp;
if (b <= -1e-59) {
tmp = t_1;
} else if (b <= 7e-204) {
tmp = fma(-t, a, (z * y)) * x;
} else if (b <= 9.6e+82) {
tmp = fma(-i, y, (c * t)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -1e-59) tmp = t_1; elseif (b <= 7e-204) tmp = Float64(fma(Float64(-t), a, Float64(z * y)) * x); elseif (b <= 9.6e+82) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -1e-59], t$95$1, If[LessEqual[b, 7e-204], N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 9.6e+82], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -1 \cdot 10^{-59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 7 \cdot 10^{-204}:\\
\;\;\;\;\mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\\
\mathbf{elif}\;b \leq 9.6 \cdot 10^{+82}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1e-59 or 9.59999999999999992e82 < b Initial program 74.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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.0
Applied rewrites70.0%
if -1e-59 < b < 7.00000000000000054e-204Initial program 76.4%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6476.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6476.4
Applied rewrites76.4%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6468.4
Applied rewrites68.4%
Taylor expanded in z around inf
Applied rewrites77.4%
Taylor expanded in x around inf
*-commutativeN/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
*-commutativeN/A
lower-*.f6467.2
Applied rewrites67.2%
if 7.00000000000000054e-204 < b < 9.59999999999999992e82Initial program 78.4%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6478.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6478.4
Applied rewrites78.4%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.1
Applied rewrites62.1%
Taylor expanded in z around inf
Applied rewrites67.0%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6453.9
Applied rewrites53.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -1e-59)
t_1
(if (<= b 2e-204)
(* (fma (- x) a (* j c)) t)
(if (<= b 9.6e+82) (* (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(-z, c, (i * a)) * b;
double tmp;
if (b <= -1e-59) {
tmp = t_1;
} else if (b <= 2e-204) {
tmp = fma(-x, a, (j * c)) * t;
} else if (b <= 9.6e+82) {
tmp = fma(-i, y, (c * t)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -1e-59) tmp = t_1; elseif (b <= 2e-204) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); elseif (b <= 9.6e+82) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -1e-59], t$95$1, If[LessEqual[b, 2e-204], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[b, 9.6e+82], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -1 \cdot 10^{-59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 2 \cdot 10^{-204}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{elif}\;b \leq 9.6 \cdot 10^{+82}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1e-59 or 9.59999999999999992e82 < b Initial program 74.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
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.0
Applied rewrites70.0%
if -1e-59 < b < 2e-204Initial program 76.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6455.5
Applied rewrites55.5%
if 2e-204 < b < 9.59999999999999992e82Initial program 78.4%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6478.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6478.4
Applied rewrites78.4%
Taylor expanded in y around 0
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.1
Applied rewrites62.1%
Taylor expanded in z around inf
Applied rewrites67.0%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6453.9
Applied rewrites53.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) t (* i b)) a)))
(if (<= a -4600000000000.0)
t_1
(if (<= a 5.6e-111)
(* (fma (- z) b (* j t)) c)
(if (<= a 2.35e+14) (* (fma y x (* (- b) c)) z) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-x, t, (i * b)) * a;
double tmp;
if (a <= -4600000000000.0) {
tmp = t_1;
} else if (a <= 5.6e-111) {
tmp = fma(-z, b, (j * t)) * c;
} else if (a <= 2.35e+14) {
tmp = fma(y, x, (-b * c)) * z;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), t, Float64(i * b)) * a) tmp = 0.0 if (a <= -4600000000000.0) tmp = t_1; elseif (a <= 5.6e-111) tmp = Float64(fma(Float64(-z), b, Float64(j * t)) * c); elseif (a <= 2.35e+14) tmp = Float64(fma(y, x, Float64(Float64(-b) * c)) * z); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[a, -4600000000000.0], t$95$1, If[LessEqual[a, 5.6e-111], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[a, 2.35e+14], N[(N[(y * x + N[((-b) * c), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{if}\;a \leq -4600000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.6 \cdot 10^{-111}:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot t\right) \cdot c\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \left(-b\right) \cdot c\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -4.6e12 or 2.35e14 < a Initial program 68.2%
Taylor expanded in a 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-*.f6471.1
Applied rewrites71.1%
if -4.6e12 < a < 5.5999999999999999e-111Initial program 80.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6452.4
Applied rewrites52.4%
if 5.5999999999999999e-111 < a < 2.35e14Initial program 89.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.8
Applied rewrites54.8%
Applied rewrites54.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- y) j (* b a)) i)))
(if (<= i -9e+47)
t_1
(if (<= i -7e-202)
(* (fma (- x) a (* j c)) t)
(if (<= i 6.2e+90) (* (fma y x (* (- b) c)) 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(-y, j, (b * a)) * i;
double tmp;
if (i <= -9e+47) {
tmp = t_1;
} else if (i <= -7e-202) {
tmp = fma(-x, a, (j * c)) * t;
} else if (i <= 6.2e+90) {
tmp = fma(y, x, (-b * c)) * z;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-y), j, Float64(b * a)) * i) tmp = 0.0 if (i <= -9e+47) tmp = t_1; elseif (i <= -7e-202) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); elseif (i <= 6.2e+90) tmp = Float64(fma(y, x, Float64(Float64(-b) * c)) * 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[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[i, -9e+47], t$95$1, If[LessEqual[i, -7e-202], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[i, 6.2e+90], N[(N[(y * x + N[((-b) * c), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-y, j, b \cdot a\right) \cdot i\\
\mathbf{if}\;i \leq -9 \cdot 10^{+47}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -7 \cdot 10^{-202}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{elif}\;i \leq 6.2 \cdot 10^{+90}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \left(-b\right) \cdot c\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -8.99999999999999958e47 or 6.19999999999999977e90 < i Initial program 66.3%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.6
Applied rewrites70.6%
if -8.99999999999999958e47 < i < -6.9999999999999998e-202Initial program 75.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6458.1
Applied rewrites58.1%
if -6.9999999999999998e-202 < i < 6.19999999999999977e90Initial program 84.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.9
Applied rewrites48.9%
Applied rewrites48.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -6e+25)
(* (* b a) i)
(if (<= a 1.75e-267)
(* (* j c) t)
(if (<= a 1.45e-118)
(* (* (- z) b) c)
(if (<= a 4.5e+18) (* (* z y) x) (* (* i b) a))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -6e+25) {
tmp = (b * a) * i;
} else if (a <= 1.75e-267) {
tmp = (j * c) * t;
} else if (a <= 1.45e-118) {
tmp = (-z * b) * c;
} else if (a <= 4.5e+18) {
tmp = (z * y) * x;
} else {
tmp = (i * b) * a;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (a <= (-6d+25)) then
tmp = (b * a) * i
else if (a <= 1.75d-267) then
tmp = (j * c) * t
else if (a <= 1.45d-118) then
tmp = (-z * b) * c
else if (a <= 4.5d+18) then
tmp = (z * y) * x
else
tmp = (i * b) * a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -6e+25) {
tmp = (b * a) * i;
} else if (a <= 1.75e-267) {
tmp = (j * c) * t;
} else if (a <= 1.45e-118) {
tmp = (-z * b) * c;
} else if (a <= 4.5e+18) {
tmp = (z * y) * x;
} else {
tmp = (i * b) * a;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if a <= -6e+25: tmp = (b * a) * i elif a <= 1.75e-267: tmp = (j * c) * t elif a <= 1.45e-118: tmp = (-z * b) * c elif a <= 4.5e+18: tmp = (z * y) * x else: tmp = (i * b) * a return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -6e+25) tmp = Float64(Float64(b * a) * i); elseif (a <= 1.75e-267) tmp = Float64(Float64(j * c) * t); elseif (a <= 1.45e-118) tmp = Float64(Float64(Float64(-z) * b) * c); elseif (a <= 4.5e+18) tmp = Float64(Float64(z * y) * x); else tmp = Float64(Float64(i * b) * a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (a <= -6e+25) tmp = (b * a) * i; elseif (a <= 1.75e-267) tmp = (j * c) * t; elseif (a <= 1.45e-118) tmp = (-z * b) * c; elseif (a <= 4.5e+18) tmp = (z * y) * x; else tmp = (i * b) * a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -6e+25], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[a, 1.75e-267], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[a, 1.45e-118], N[(N[((-z) * b), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[a, 4.5e+18], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -6 \cdot 10^{+25}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;a \leq 1.75 \cdot 10^{-267}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{elif}\;a \leq 1.45 \cdot 10^{-118}:\\
\;\;\;\;\left(\left(-z\right) \cdot b\right) \cdot c\\
\mathbf{elif}\;a \leq 4.5 \cdot 10^{+18}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\end{array}
\end{array}
if a < -6.00000000000000011e25Initial program 64.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-*.f6451.3
Applied rewrites51.3%
Taylor expanded in y around 0
Applied rewrites40.8%
if -6.00000000000000011e25 < a < 1.75e-267Initial program 82.0%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6482.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6482.0
Applied rewrites82.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6442.1
Applied rewrites42.1%
Taylor expanded in x around 0
Applied rewrites35.5%
if 1.75e-267 < a < 1.4499999999999999e-118Initial program 76.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6444.9
Applied rewrites44.9%
Taylor expanded in x around 0
Applied rewrites45.0%
if 1.4499999999999999e-118 < a < 4.5e18Initial program 89.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.4
Applied rewrites51.4%
Taylor expanded in x around inf
Applied rewrites47.8%
if 4.5e18 < a Initial program 70.1%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.0
Applied rewrites47.0%
Taylor expanded in y around 0
Applied rewrites44.9%
Final simplification41.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* j c) t)) (t_2 (* (* b a) i)))
(if (<= j -1.5e+270)
t_2
(if (<= j -5.3e+110)
t_1
(if (<= j 7.8e-238) t_2 (if (<= j 6.5e-42) (* (* 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 = (j * c) * t;
double t_2 = (b * a) * i;
double tmp;
if (j <= -1.5e+270) {
tmp = t_2;
} else if (j <= -5.3e+110) {
tmp = t_1;
} else if (j <= 7.8e-238) {
tmp = t_2;
} else if (j <= 6.5e-42) {
tmp = (y * x) * z;
} 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) :: t_2
real(8) :: tmp
t_1 = (j * c) * t
t_2 = (b * a) * i
if (j <= (-1.5d+270)) then
tmp = t_2
else if (j <= (-5.3d+110)) then
tmp = t_1
else if (j <= 7.8d-238) then
tmp = t_2
else if (j <= 6.5d-42) then
tmp = (y * x) * z
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 = (j * c) * t;
double t_2 = (b * a) * i;
double tmp;
if (j <= -1.5e+270) {
tmp = t_2;
} else if (j <= -5.3e+110) {
tmp = t_1;
} else if (j <= 7.8e-238) {
tmp = t_2;
} else if (j <= 6.5e-42) {
tmp = (y * x) * z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (j * c) * t t_2 = (b * a) * i tmp = 0 if j <= -1.5e+270: tmp = t_2 elif j <= -5.3e+110: tmp = t_1 elif j <= 7.8e-238: tmp = t_2 elif j <= 6.5e-42: tmp = (y * x) * z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(j * c) * t) t_2 = Float64(Float64(b * a) * i) tmp = 0.0 if (j <= -1.5e+270) tmp = t_2; elseif (j <= -5.3e+110) tmp = t_1; elseif (j <= 7.8e-238) tmp = t_2; elseif (j <= 6.5e-42) tmp = Float64(Float64(y * x) * z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (j * c) * t; t_2 = (b * a) * i; tmp = 0.0; if (j <= -1.5e+270) tmp = t_2; elseif (j <= -5.3e+110) tmp = t_1; elseif (j <= 7.8e-238) tmp = t_2; elseif (j <= 6.5e-42) tmp = (y * x) * z; 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[(j * c), $MachinePrecision] * t), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[j, -1.5e+270], t$95$2, If[LessEqual[j, -5.3e+110], t$95$1, If[LessEqual[j, 7.8e-238], t$95$2, If[LessEqual[j, 6.5e-42], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(j \cdot c\right) \cdot t\\
t_2 := \left(b \cdot a\right) \cdot i\\
\mathbf{if}\;j \leq -1.5 \cdot 10^{+270}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq -5.3 \cdot 10^{+110}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 7.8 \cdot 10^{-238}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq 6.5 \cdot 10^{-42}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.50000000000000007e270 or -5.2999999999999998e110 < j < 7.7999999999999997e-238Initial program 70.2%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.0
Applied rewrites48.0%
Taylor expanded in y around 0
Applied rewrites33.6%
if -1.50000000000000007e270 < j < -5.2999999999999998e110 or 6.4999999999999998e-42 < j Initial program 79.7%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6479.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6479.7
Applied rewrites79.7%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6455.7
Applied rewrites55.7%
Taylor expanded in x around 0
Applied rewrites43.8%
if 7.7999999999999997e-238 < j < 6.4999999999999998e-42Initial program 83.5%
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
*-commutativeN/A
lower-*.f6467.7
Applied rewrites67.7%
Taylor expanded in x around inf
Applied rewrites46.4%
Final simplification39.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= t -6.1e+221)
(* (* j t) c)
(if (<= t 4.4e+66)
(* (fma y x (* (- b) c)) z)
(if (<= t 1.1e+162) (* (* j c) t) (* (* (- x) t) a)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (t <= -6.1e+221) {
tmp = (j * t) * c;
} else if (t <= 4.4e+66) {
tmp = fma(y, x, (-b * c)) * z;
} else if (t <= 1.1e+162) {
tmp = (j * c) * t;
} else {
tmp = (-x * t) * a;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (t <= -6.1e+221) tmp = Float64(Float64(j * t) * c); elseif (t <= 4.4e+66) tmp = Float64(fma(y, x, Float64(Float64(-b) * c)) * z); elseif (t <= 1.1e+162) tmp = Float64(Float64(j * c) * t); else tmp = Float64(Float64(Float64(-x) * t) * a); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[t, -6.1e+221], N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[t, 4.4e+66], N[(N[(y * x + N[((-b) * c), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 1.1e+162], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], N[(N[((-x) * t), $MachinePrecision] * a), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -6.1 \cdot 10^{+221}:\\
\;\;\;\;\left(j \cdot t\right) \cdot c\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{+66}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \left(-b\right) \cdot c\right) \cdot z\\
\mathbf{elif}\;t \leq 1.1 \cdot 10^{+162}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-x\right) \cdot t\right) \cdot a\\
\end{array}
\end{array}
if t < -6.0999999999999998e221Initial program 56.7%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6456.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6456.7
Applied rewrites56.7%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6467.0
Applied rewrites67.0%
Taylor expanded in x around 0
Applied rewrites56.1%
if -6.0999999999999998e221 < t < 4.3999999999999997e66Initial program 79.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6444.7
Applied rewrites44.7%
Applied rewrites44.7%
if 4.3999999999999997e66 < t < 1.1000000000000001e162Initial program 75.1%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6475.1
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6475.1
Applied rewrites75.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6475.9
Applied rewrites75.9%
Taylor expanded in x around 0
Applied rewrites57.7%
if 1.1000000000000001e162 < t Initial program 67.7%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6467.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6467.7
Applied rewrites67.7%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6480.8
Applied rewrites80.8%
Taylor expanded in x around inf
Applied rewrites61.7%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (fma (- z) c (* i a)) b))) (if (<= b -1e-59) t_1 (if (<= b 8.6e+43) (* (fma (- x) a (* j c)) t) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -1e-59) {
tmp = t_1;
} else if (b <= 8.6e+43) {
tmp = fma(-x, a, (j * c)) * t;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -1e-59) tmp = t_1; elseif (b <= 8.6e+43) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -1e-59], t$95$1, If[LessEqual[b, 8.6e+43], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -1 \cdot 10^{-59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 8.6 \cdot 10^{+43}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1e-59 or 8.6e43 < b Initial program 76.0%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6467.4
Applied rewrites67.4%
if -1e-59 < b < 8.6e43Initial program 76.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.3
Applied rewrites52.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) t (* i b)) a)))
(if (<= a -4.1e-89)
t_1
(if (<= a 2.35e+14) (* (fma y x (* (- b) c)) z) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-x, t, (i * b)) * a;
double tmp;
if (a <= -4.1e-89) {
tmp = t_1;
} else if (a <= 2.35e+14) {
tmp = fma(y, x, (-b * c)) * z;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), t, Float64(i * b)) * a) tmp = 0.0 if (a <= -4.1e-89) tmp = t_1; elseif (a <= 2.35e+14) tmp = Float64(fma(y, x, Float64(Float64(-b) * c)) * z); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[a, -4.1e-89], t$95$1, If[LessEqual[a, 2.35e+14], N[(N[(y * x + N[((-b) * c), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{if}\;a \leq -4.1 \cdot 10^{-89}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \left(-b\right) \cdot c\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -4.0999999999999998e-89 or 2.35e14 < a Initial program 72.1%
Taylor expanded in a 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 -4.0999999999999998e-89 < a < 2.35e14Initial program 80.5%
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
*-commutativeN/A
lower-*.f6445.2
Applied rewrites45.2%
Applied rewrites46.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* j t) c)))
(if (<= j -3.4e+24)
t_1
(if (<= j 7.8e-238)
(* (* b a) i)
(if (<= j 6.5e-42) (* (* 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 = (j * t) * c;
double tmp;
if (j <= -3.4e+24) {
tmp = t_1;
} else if (j <= 7.8e-238) {
tmp = (b * a) * i;
} else if (j <= 6.5e-42) {
tmp = (y * x) * z;
} 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 = (j * t) * c
if (j <= (-3.4d+24)) then
tmp = t_1
else if (j <= 7.8d-238) then
tmp = (b * a) * i
else if (j <= 6.5d-42) then
tmp = (y * x) * z
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 = (j * t) * c;
double tmp;
if (j <= -3.4e+24) {
tmp = t_1;
} else if (j <= 7.8e-238) {
tmp = (b * a) * i;
} else if (j <= 6.5e-42) {
tmp = (y * x) * z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (j * t) * c tmp = 0 if j <= -3.4e+24: tmp = t_1 elif j <= 7.8e-238: tmp = (b * a) * i elif j <= 6.5e-42: tmp = (y * x) * z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(j * t) * c) tmp = 0.0 if (j <= -3.4e+24) tmp = t_1; elseif (j <= 7.8e-238) tmp = Float64(Float64(b * a) * i); elseif (j <= 6.5e-42) tmp = Float64(Float64(y * x) * z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (j * t) * c; tmp = 0.0; if (j <= -3.4e+24) tmp = t_1; elseif (j <= 7.8e-238) tmp = (b * a) * i; elseif (j <= 6.5e-42) tmp = (y * x) * z; 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[(j * t), $MachinePrecision] * c), $MachinePrecision]}, If[LessEqual[j, -3.4e+24], t$95$1, If[LessEqual[j, 7.8e-238], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[j, 6.5e-42], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(j \cdot t\right) \cdot c\\
\mathbf{if}\;j \leq -3.4 \cdot 10^{+24}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 7.8 \cdot 10^{-238}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;j \leq 6.5 \cdot 10^{-42}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -3.4000000000000001e24 or 6.4999999999999998e-42 < j Initial program 74.6%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6474.6
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6474.6
Applied rewrites74.6%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.0
Applied rewrites48.0%
Taylor expanded in x around 0
Applied rewrites34.8%
if -3.4000000000000001e24 < j < 7.7999999999999997e-238Initial program 74.6%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6446.2
Applied rewrites46.2%
Taylor expanded in y around 0
Applied rewrites33.6%
if 7.7999999999999997e-238 < j < 6.4999999999999998e-42Initial program 83.5%
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
*-commutativeN/A
lower-*.f6467.7
Applied rewrites67.7%
Taylor expanded in x around inf
Applied rewrites46.4%
Final simplification36.3%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= b -1.3e+83) (* (* i b) a) (if (<= b 4.2e+44) (* (* z y) x) (* (* b a) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -1.3e+83) {
tmp = (i * b) * a;
} else if (b <= 4.2e+44) {
tmp = (z * y) * x;
} else {
tmp = (b * a) * i;
}
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 (b <= (-1.3d+83)) then
tmp = (i * b) * a
else if (b <= 4.2d+44) then
tmp = (z * y) * x
else
tmp = (b * a) * i
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 (b <= -1.3e+83) {
tmp = (i * b) * a;
} else if (b <= 4.2e+44) {
tmp = (z * y) * x;
} else {
tmp = (b * a) * i;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -1.3e+83: tmp = (i * b) * a elif b <= 4.2e+44: tmp = (z * y) * x else: tmp = (b * a) * i return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -1.3e+83) tmp = Float64(Float64(i * b) * a); elseif (b <= 4.2e+44) tmp = Float64(Float64(z * y) * x); else tmp = Float64(Float64(b * a) * i); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -1.3e+83) tmp = (i * b) * a; elseif (b <= 4.2e+44) tmp = (z * y) * x; else tmp = (b * a) * i; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -1.3e+83], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[b, 4.2e+44], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.3 \cdot 10^{+83}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;b \leq 4.2 \cdot 10^{+44}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\end{array}
\end{array}
if b < -1.3000000000000001e83Initial program 75.0%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.9
Applied rewrites47.9%
Taylor expanded in y around 0
Applied rewrites42.9%
if -1.3000000000000001e83 < b < 4.19999999999999974e44Initial program 76.3%
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
*-commutativeN/A
lower-*.f6432.8
Applied rewrites32.8%
Taylor expanded in x around inf
Applied rewrites26.5%
if 4.19999999999999974e44 < b Initial program 76.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-*.f6452.4
Applied rewrites52.4%
Taylor expanded in y around 0
Applied rewrites44.7%
Final simplification34.0%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* i b) a))) (if (<= b -1.3e+83) t_1 (if (<= b 1.2e+45) (* (* z y) x) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * b) * a;
double tmp;
if (b <= -1.3e+83) {
tmp = t_1;
} else if (b <= 1.2e+45) {
tmp = (z * y) * x;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (i * b) * a
if (b <= (-1.3d+83)) then
tmp = t_1
else if (b <= 1.2d+45) then
tmp = (z * y) * x
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * b) * a;
double tmp;
if (b <= -1.3e+83) {
tmp = t_1;
} else if (b <= 1.2e+45) {
tmp = (z * y) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * b) * a tmp = 0 if b <= -1.3e+83: tmp = t_1 elif b <= 1.2e+45: tmp = (z * y) * x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * b) * a) tmp = 0.0 if (b <= -1.3e+83) tmp = t_1; elseif (b <= 1.2e+45) tmp = Float64(Float64(z * y) * x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (i * b) * a; tmp = 0.0; if (b <= -1.3e+83) tmp = t_1; elseif (b <= 1.2e+45) tmp = (z * y) * x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[b, -1.3e+83], t$95$1, If[LessEqual[b, 1.2e+45], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot a\\
\mathbf{if}\;b \leq -1.3 \cdot 10^{+83}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.2 \cdot 10^{+45}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.3000000000000001e83 or 1.19999999999999995e45 < b Initial program 75.7%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.0
Applied rewrites50.0%
Taylor expanded in y around 0
Applied rewrites43.0%
if -1.3000000000000001e83 < b < 1.19999999999999995e45Initial program 76.3%
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
*-commutativeN/A
lower-*.f6432.8
Applied rewrites32.8%
Taylor expanded in x around inf
Applied rewrites26.5%
Final simplification33.6%
(FPCore (x y z t a b c i j) :precision binary64 (* (* z y) x))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * y) * x;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = (z * y) * x
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * y) * x;
}
def code(x, y, z, t, a, b, c, i, j): return (z * y) * x
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(z * y) * x) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (z * y) * x; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]
\begin{array}{l}
\\
\left(z \cdot y\right) \cdot x
\end{array}
Initial program 76.1%
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
*-commutativeN/A
lower-*.f6437.0
Applied rewrites37.0%
Taylor expanded in x around inf
Applied rewrites20.8%
Final simplification20.8%
(FPCore (x y z t a b c i j) :precision binary64 (* (* z x) y))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * x) * y;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = (z * x) * y
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * x) * y;
}
def code(x, y, z, t, a, b, c, i, j): return (z * x) * y
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(z * x) * y) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (z * x) * y; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision]
\begin{array}{l}
\\
\left(z \cdot x\right) \cdot y
\end{array}
Initial program 76.1%
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
*-commutativeN/A
lower-*.f6437.0
Applied rewrites37.0%
Taylor expanded in x around inf
Applied rewrites20.8%
Applied rewrites19.2%
Final simplification19.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 2024294
(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)))))