
(FPCore (x y z t a b c i j k) :precision binary64 (- (- (+ (- (* (* (* (* x 18.0) y) z) t) (* (* a 4.0) t)) (* b c)) (* (* x 4.0) i)) (* (* j 27.0) k)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}
real(8) function code(x, y, z, t, a, b, c, i, j, k)
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), intent (in) :: k
code = (((((((x * 18.0d0) * y) * z) * t) - ((a * 4.0d0) * t)) + (b * c)) - ((x * 4.0d0) * i)) - ((j * 27.0d0) * k)
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 k) {
return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}
def code(x, y, z, t, a, b, c, i, j, k): return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k)
function code(x, y, z, t, a, b, c, i, j, k) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 18.0) * y) * z) * t) - Float64(Float64(a * 4.0) * t)) + Float64(b * c)) - Float64(Float64(x * 4.0) * i)) - Float64(Float64(j * 27.0) * k)) end
function tmp = code(x, y, z, t, a, b, c, i, j, k) tmp = (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := N[(N[(N[(N[(N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision] - N[(N[(a * 4.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j k) :precision binary64 (- (- (+ (- (* (* (* (* x 18.0) y) z) t) (* (* a 4.0) t)) (* b c)) (* (* x 4.0) i)) (* (* j 27.0) k)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}
real(8) function code(x, y, z, t, a, b, c, i, j, k)
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), intent (in) :: k
code = (((((((x * 18.0d0) * y) * z) * t) - ((a * 4.0d0) * t)) + (b * c)) - ((x * 4.0d0) * i)) - ((j * 27.0d0) * k)
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 k) {
return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
}
def code(x, y, z, t, a, b, c, i, j, k): return (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k)
function code(x, y, z, t, a, b, c, i, j, k) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 18.0) * y) * z) * t) - Float64(Float64(a * 4.0) * t)) + Float64(b * c)) - Float64(Float64(x * 4.0) * i)) - Float64(Float64(j * 27.0) * k)) end
function tmp = code(x, y, z, t, a, b, c, i, j, k) tmp = (((((((x * 18.0) * y) * z) * t) - ((a * 4.0) * t)) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := N[(N[(N[(N[(N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision] - N[(N[(a * 4.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - \left(a \cdot 4\right) \cdot t\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k
\end{array}
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(if (<= i 4e+97)
(fma
(* -27.0 k)
j
(fma (* -4.0 i) x (fma t (fma (* (* z y) 18.0) x (* a -4.0)) (* c b))))
(fma c b (fma (fma i x (* a t)) -4.0 (* (* j k) -27.0)))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if (i <= 4e+97) {
tmp = fma((-27.0 * k), j, fma((-4.0 * i), x, fma(t, fma(((z * y) * 18.0), x, (a * -4.0)), (c * b))));
} else {
tmp = fma(c, b, fma(fma(i, x, (a * t)), -4.0, ((j * k) * -27.0)));
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (i <= 4e+97) tmp = fma(Float64(-27.0 * k), j, fma(Float64(-4.0 * i), x, fma(t, fma(Float64(Float64(z * y) * 18.0), x, Float64(a * -4.0)), Float64(c * b)))); else tmp = fma(c, b, fma(fma(i, x, Float64(a * t)), -4.0, Float64(Float64(j * k) * -27.0))); end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[i, 4e+97], N[(N[(-27.0 * k), $MachinePrecision] * j + N[(N[(-4.0 * i), $MachinePrecision] * x + N[(t * N[(N[(N[(z * y), $MachinePrecision] * 18.0), $MachinePrecision] * x + N[(a * -4.0), $MachinePrecision]), $MachinePrecision] + N[(c * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c * b + N[(N[(i * x + N[(a * t), $MachinePrecision]), $MachinePrecision] * -4.0 + N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;i \leq 4 \cdot 10^{+97}:\\
\;\;\;\;\mathsf{fma}\left(-27 \cdot k, j, \mathsf{fma}\left(-4 \cdot i, x, \mathsf{fma}\left(t, \mathsf{fma}\left(\left(z \cdot y\right) \cdot 18, x, a \cdot -4\right), c \cdot b\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(\mathsf{fma}\left(i, x, a \cdot t\right), -4, \left(j \cdot k\right) \cdot -27\right)\right)\\
\end{array}
\end{array}
if i < 4.0000000000000003e97Initial program 81.9%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval84.7
lift--.f64N/A
sub-negN/A
Applied rewrites91.2%
Applied rewrites94.9%
if 4.0000000000000003e97 < i Initial program 85.7%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites91.7%
Final simplification94.4%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1
(fma
(* t -4.0)
a
(fma (fma i -4.0 (* (* (* z y) t) 18.0)) x (* c b))))
(t_2
(-
(+ (- (* (* (* (* 18.0 x) y) z) t) (* (* 4.0 a) t)) (* c b))
(* (* 4.0 x) i))))
(if (<= t_2 -4e+208)
t_1
(if (<= t_2 5e+306)
(fma c b (fma (fma i x (* a t)) -4.0 (* (* j k) -27.0)))
t_1))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = fma((t * -4.0), a, fma(fma(i, -4.0, (((z * y) * t) * 18.0)), x, (c * b)));
double t_2 = ((((((18.0 * x) * y) * z) * t) - ((4.0 * a) * t)) + (c * b)) - ((4.0 * x) * i);
double tmp;
if (t_2 <= -4e+208) {
tmp = t_1;
} else if (t_2 <= 5e+306) {
tmp = fma(c, b, fma(fma(i, x, (a * t)), -4.0, ((j * k) * -27.0)));
} else {
tmp = t_1;
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = fma(Float64(t * -4.0), a, fma(fma(i, -4.0, Float64(Float64(Float64(z * y) * t) * 18.0)), x, Float64(c * b))) t_2 = Float64(Float64(Float64(Float64(Float64(Float64(Float64(18.0 * x) * y) * z) * t) - Float64(Float64(4.0 * a) * t)) + Float64(c * b)) - Float64(Float64(4.0 * x) * i)) tmp = 0.0 if (t_2 <= -4e+208) tmp = t_1; elseif (t_2 <= 5e+306) tmp = fma(c, b, fma(fma(i, x, Float64(a * t)), -4.0, Float64(Float64(j * k) * -27.0))); else tmp = t_1; end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(t * -4.0), $MachinePrecision] * a + N[(N[(i * -4.0 + N[(N[(N[(z * y), $MachinePrecision] * t), $MachinePrecision] * 18.0), $MachinePrecision]), $MachinePrecision] * x + N[(c * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(N[(N[(N[(18.0 * x), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision] - N[(N[(4.0 * a), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(c * b), $MachinePrecision]), $MachinePrecision] - N[(N[(4.0 * x), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -4e+208], t$95$1, If[LessEqual[t$95$2, 5e+306], N[(c * b + N[(N[(i * x + N[(a * t), $MachinePrecision]), $MachinePrecision] * -4.0 + N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t \cdot -4, a, \mathsf{fma}\left(\mathsf{fma}\left(i, -4, \left(\left(z \cdot y\right) \cdot t\right) \cdot 18\right), x, c \cdot b\right)\right)\\
t_2 := \left(\left(\left(\left(\left(18 \cdot x\right) \cdot y\right) \cdot z\right) \cdot t - \left(4 \cdot a\right) \cdot t\right) + c \cdot b\right) - \left(4 \cdot x\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -4 \cdot 10^{+208}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+306}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(\mathsf{fma}\left(i, x, a \cdot t\right), -4, \left(j \cdot k\right) \cdot -27\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (-.f64 (+.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 x #s(literal 18 binary64)) y) z) t) (*.f64 (*.f64 a #s(literal 4 binary64)) t)) (*.f64 b c)) (*.f64 (*.f64 x #s(literal 4 binary64)) i)) < -3.9999999999999999e208 or 4.99999999999999993e306 < (-.f64 (+.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 x #s(literal 18 binary64)) y) z) t) (*.f64 (*.f64 a #s(literal 4 binary64)) t)) (*.f64 b c)) (*.f64 (*.f64 x #s(literal 4 binary64)) i)) Initial program 70.1%
Taylor expanded in j around 0
associate--r+N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
associate--l+N/A
*-commutativeN/A
associate-*r*N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites88.5%
if -3.9999999999999999e208 < (-.f64 (+.f64 (-.f64 (*.f64 (*.f64 (*.f64 (*.f64 x #s(literal 18 binary64)) y) z) t) (*.f64 (*.f64 a #s(literal 4 binary64)) t)) (*.f64 b c)) (*.f64 (*.f64 x #s(literal 4 binary64)) i)) < 4.99999999999999993e306Initial program 99.0%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites90.4%
Final simplification89.3%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(if (<= c 9.5e+226)
(fma
(* -27.0 k)
j
(fma (* x i) -4.0 (fma (fma z (* (* 18.0 x) y) (* a -4.0)) t (* c b))))
(fma c b (fma (fma i x (* a t)) -4.0 (* (* j k) -27.0)))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if (c <= 9.5e+226) {
tmp = fma((-27.0 * k), j, fma((x * i), -4.0, fma(fma(z, ((18.0 * x) * y), (a * -4.0)), t, (c * b))));
} else {
tmp = fma(c, b, fma(fma(i, x, (a * t)), -4.0, ((j * k) * -27.0)));
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (c <= 9.5e+226) tmp = fma(Float64(-27.0 * k), j, fma(Float64(x * i), -4.0, fma(fma(z, Float64(Float64(18.0 * x) * y), Float64(a * -4.0)), t, Float64(c * b)))); else tmp = fma(c, b, fma(fma(i, x, Float64(a * t)), -4.0, Float64(Float64(j * k) * -27.0))); end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[c, 9.5e+226], N[(N[(-27.0 * k), $MachinePrecision] * j + N[(N[(x * i), $MachinePrecision] * -4.0 + N[(N[(z * N[(N[(18.0 * x), $MachinePrecision] * y), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision] * t + N[(c * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c * b + N[(N[(i * x + N[(a * t), $MachinePrecision]), $MachinePrecision] * -4.0 + N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;c \leq 9.5 \cdot 10^{+226}:\\
\;\;\;\;\mathsf{fma}\left(-27 \cdot k, j, \mathsf{fma}\left(x \cdot i, -4, \mathsf{fma}\left(\mathsf{fma}\left(z, \left(18 \cdot x\right) \cdot y, a \cdot -4\right), t, c \cdot b\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(\mathsf{fma}\left(i, x, a \cdot t\right), -4, \left(j \cdot k\right) \cdot -27\right)\right)\\
\end{array}
\end{array}
if c < 9.50000000000000088e226Initial program 84.6%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval87.1
lift--.f64N/A
sub-negN/A
Applied rewrites92.6%
if 9.50000000000000088e226 < c Initial program 53.1%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites82.6%
Final simplification91.9%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (* 27.0 j) k)))
(if (<= t_1 -4e+257)
(* (* j -27.0) k)
(if (<= t_1 -1e-92)
(* (* t -4.0) a)
(if (<= t_1 2e+70) (* c b) (* (* -27.0 k) j))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = (27.0 * j) * k;
double tmp;
if (t_1 <= -4e+257) {
tmp = (j * -27.0) * k;
} else if (t_1 <= -1e-92) {
tmp = (t * -4.0) * a;
} else if (t_1 <= 2e+70) {
tmp = c * b;
} else {
tmp = (-27.0 * k) * j;
}
return tmp;
}
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
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), intent (in) :: k
real(8) :: t_1
real(8) :: tmp
t_1 = (27.0d0 * j) * k
if (t_1 <= (-4d+257)) then
tmp = (j * (-27.0d0)) * k
else if (t_1 <= (-1d-92)) then
tmp = (t * (-4.0d0)) * a
else if (t_1 <= 2d+70) then
tmp = c * b
else
tmp = ((-27.0d0) * k) * j
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = (27.0 * j) * k;
double tmp;
if (t_1 <= -4e+257) {
tmp = (j * -27.0) * k;
} else if (t_1 <= -1e-92) {
tmp = (t * -4.0) * a;
} else if (t_1 <= 2e+70) {
tmp = c * b;
} else {
tmp = (-27.0 * k) * j;
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = (27.0 * j) * k tmp = 0 if t_1 <= -4e+257: tmp = (j * -27.0) * k elif t_1 <= -1e-92: tmp = (t * -4.0) * a elif t_1 <= 2e+70: tmp = c * b else: tmp = (-27.0 * k) * j return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(Float64(27.0 * j) * k) tmp = 0.0 if (t_1 <= -4e+257) tmp = Float64(Float64(j * -27.0) * k); elseif (t_1 <= -1e-92) tmp = Float64(Float64(t * -4.0) * a); elseif (t_1 <= 2e+70) tmp = Float64(c * b); else tmp = Float64(Float64(-27.0 * k) * j); end return tmp end
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
t_1 = (27.0 * j) * k;
tmp = 0.0;
if (t_1 <= -4e+257)
tmp = (j * -27.0) * k;
elseif (t_1 <= -1e-92)
tmp = (t * -4.0) * a;
elseif (t_1 <= 2e+70)
tmp = c * b;
else
tmp = (-27.0 * k) * j;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(27.0 * j), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -4e+257], N[(N[(j * -27.0), $MachinePrecision] * k), $MachinePrecision], If[LessEqual[t$95$1, -1e-92], N[(N[(t * -4.0), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t$95$1, 2e+70], N[(c * b), $MachinePrecision], N[(N[(-27.0 * k), $MachinePrecision] * j), $MachinePrecision]]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \left(27 \cdot j\right) \cdot k\\
\mathbf{if}\;t\_1 \leq -4 \cdot 10^{+257}:\\
\;\;\;\;\left(j \cdot -27\right) \cdot k\\
\mathbf{elif}\;t\_1 \leq -1 \cdot 10^{-92}:\\
\;\;\;\;\left(t \cdot -4\right) \cdot a\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+70}:\\
\;\;\;\;c \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(-27 \cdot k\right) \cdot j\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -4.00000000000000012e257Initial program 87.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f648.2
Applied rewrites8.2%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6487.6
Applied rewrites87.6%
Applied rewrites87.6%
if -4.00000000000000012e257 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -9.99999999999999988e-93Initial program 89.0%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6436.3
Applied rewrites36.3%
if -9.99999999999999988e-93 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 2.00000000000000015e70Initial program 83.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6437.7
Applied rewrites37.7%
if 2.00000000000000015e70 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 72.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6411.8
Applied rewrites11.8%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6449.1
Applied rewrites49.1%
Applied rewrites49.1%
Final simplification43.1%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1
(fma
(* -27.0 k)
j
(fma (fma (* (* z y) x) 18.0 (* a -4.0)) t (* c b)))))
(if (<= t -8.8e-14)
t_1
(if (<= t 8.6e+82)
(fma c b (fma (fma i x (* a t)) -4.0 (* (* j k) -27.0)))
t_1))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = fma((-27.0 * k), j, fma(fma(((z * y) * x), 18.0, (a * -4.0)), t, (c * b)));
double tmp;
if (t <= -8.8e-14) {
tmp = t_1;
} else if (t <= 8.6e+82) {
tmp = fma(c, b, fma(fma(i, x, (a * t)), -4.0, ((j * k) * -27.0)));
} else {
tmp = t_1;
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = fma(Float64(-27.0 * k), j, fma(fma(Float64(Float64(z * y) * x), 18.0, Float64(a * -4.0)), t, Float64(c * b))) tmp = 0.0 if (t <= -8.8e-14) tmp = t_1; elseif (t <= 8.6e+82) tmp = fma(c, b, fma(fma(i, x, Float64(a * t)), -4.0, Float64(Float64(j * k) * -27.0))); else tmp = t_1; end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(-27.0 * k), $MachinePrecision] * j + N[(N[(N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision] * 18.0 + N[(a * -4.0), $MachinePrecision]), $MachinePrecision] * t + N[(c * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8.8e-14], t$95$1, If[LessEqual[t, 8.6e+82], N[(c * b + N[(N[(i * x + N[(a * t), $MachinePrecision]), $MachinePrecision] * -4.0 + N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-27 \cdot k, j, \mathsf{fma}\left(\mathsf{fma}\left(\left(z \cdot y\right) \cdot x, 18, a \cdot -4\right), t, c \cdot b\right)\right)\\
\mathbf{if}\;t \leq -8.8 \cdot 10^{-14}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 8.6 \cdot 10^{+82}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(\mathsf{fma}\left(i, x, a \cdot t\right), -4, \left(j \cdot k\right) \cdot -27\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -8.8000000000000004e-14 or 8.60000000000000029e82 < t Initial program 76.2%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval80.6
lift--.f64N/A
sub-negN/A
Applied rewrites91.1%
Taylor expanded in i around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6491.4
Applied rewrites91.4%
if -8.8000000000000004e-14 < t < 8.60000000000000029e82Initial program 89.5%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites90.5%
Final simplification91.0%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (* 27.0 j) k)))
(if (<= t_1 -2e+216)
(fma (* -27.0 k) j (* (* a t) -4.0))
(if (<= t_1 5e+188)
(fma c b (* (fma a t (* x i)) -4.0))
(fma (* -27.0 k) j (* (* x i) -4.0))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = (27.0 * j) * k;
double tmp;
if (t_1 <= -2e+216) {
tmp = fma((-27.0 * k), j, ((a * t) * -4.0));
} else if (t_1 <= 5e+188) {
tmp = fma(c, b, (fma(a, t, (x * i)) * -4.0));
} else {
tmp = fma((-27.0 * k), j, ((x * i) * -4.0));
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(Float64(27.0 * j) * k) tmp = 0.0 if (t_1 <= -2e+216) tmp = fma(Float64(-27.0 * k), j, Float64(Float64(a * t) * -4.0)); elseif (t_1 <= 5e+188) tmp = fma(c, b, Float64(fma(a, t, Float64(x * i)) * -4.0)); else tmp = fma(Float64(-27.0 * k), j, Float64(Float64(x * i) * -4.0)); end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(27.0 * j), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+216], N[(N[(-27.0 * k), $MachinePrecision] * j + N[(N[(a * t), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+188], N[(c * b + N[(N[(a * t + N[(x * i), $MachinePrecision]), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision], N[(N[(-27.0 * k), $MachinePrecision] * j + N[(N[(x * i), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \left(27 \cdot j\right) \cdot k\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+216}:\\
\;\;\;\;\mathsf{fma}\left(-27 \cdot k, j, \left(a \cdot t\right) \cdot -4\right)\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+188}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(a, t, x \cdot i\right) \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-27 \cdot k, j, \left(x \cdot i\right) \cdot -4\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -2e216Initial program 90.5%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval90.6
lift--.f64N/A
sub-negN/A
Applied rewrites90.6%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6495.4
Applied rewrites95.4%
if -2e216 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 5.0000000000000001e188Initial program 85.6%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites77.1%
Taylor expanded in k around 0
Applied rewrites70.9%
if 5.0000000000000001e188 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 65.0%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval79.0
lift--.f64N/A
sub-negN/A
Applied rewrites85.9%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6470.0
Applied rewrites70.0%
Final simplification72.6%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(if (<= t -3.5e+128)
(* (fma a -4.0 (* (* (* z y) x) 18.0)) t)
(if (<= t 8.5e+83)
(fma c b (fma (fma i x (* a t)) -4.0 (* (* j k) -27.0)))
(- (* (fma (* (* -18.0 y) x) z (* 4.0 a)) (- t)) (* (* 27.0 j) k)))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if (t <= -3.5e+128) {
tmp = fma(a, -4.0, (((z * y) * x) * 18.0)) * t;
} else if (t <= 8.5e+83) {
tmp = fma(c, b, fma(fma(i, x, (a * t)), -4.0, ((j * k) * -27.0)));
} else {
tmp = (fma(((-18.0 * y) * x), z, (4.0 * a)) * -t) - ((27.0 * j) * k);
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (t <= -3.5e+128) tmp = Float64(fma(a, -4.0, Float64(Float64(Float64(z * y) * x) * 18.0)) * t); elseif (t <= 8.5e+83) tmp = fma(c, b, fma(fma(i, x, Float64(a * t)), -4.0, Float64(Float64(j * k) * -27.0))); else tmp = Float64(Float64(fma(Float64(Float64(-18.0 * y) * x), z, Float64(4.0 * a)) * Float64(-t)) - Float64(Float64(27.0 * j) * k)); end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[t, -3.5e+128], N[(N[(a * -4.0 + N[(N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision] * 18.0), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t, 8.5e+83], N[(c * b + N[(N[(i * x + N[(a * t), $MachinePrecision]), $MachinePrecision] * -4.0 + N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(-18.0 * y), $MachinePrecision] * x), $MachinePrecision] * z + N[(4.0 * a), $MachinePrecision]), $MachinePrecision] * (-t)), $MachinePrecision] - N[(N[(27.0 * j), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.5 \cdot 10^{+128}:\\
\;\;\;\;\mathsf{fma}\left(a, -4, \left(\left(z \cdot y\right) \cdot x\right) \cdot 18\right) \cdot t\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{+83}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(\mathsf{fma}\left(i, x, a \cdot t\right), -4, \left(j \cdot k\right) \cdot -27\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(-18 \cdot y\right) \cdot x, z, 4 \cdot a\right) \cdot \left(-t\right) - \left(27 \cdot j\right) \cdot k\\
\end{array}
\end{array}
if t < -3.49999999999999969e128Initial program 79.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6478.5
Applied rewrites78.5%
if -3.49999999999999969e128 < t < 8.4999999999999995e83Initial program 88.7%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites87.9%
if 8.4999999999999995e83 < t Initial program 69.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6438.1
Applied rewrites38.1%
Taylor expanded in t around -inf
associate-*r*N/A
sub-negN/A
metadata-evalN/A
associate-*r*N/A
neg-mul-1N/A
distribute-lft-inN/A
+-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
metadata-evalN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
Applied rewrites83.0%
Final simplification85.0%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (* a t) -4.0)) (t_2 (* (* 27.0 j) k)))
(if (<= t_2 -1e+107)
(fma (* -27.0 k) j t_1)
(if (<= t_2 5e+119) (fma c b t_1) (fma (* -27.0 k) j (* (* x i) -4.0))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = (a * t) * -4.0;
double t_2 = (27.0 * j) * k;
double tmp;
if (t_2 <= -1e+107) {
tmp = fma((-27.0 * k), j, t_1);
} else if (t_2 <= 5e+119) {
tmp = fma(c, b, t_1);
} else {
tmp = fma((-27.0 * k), j, ((x * i) * -4.0));
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(Float64(a * t) * -4.0) t_2 = Float64(Float64(27.0 * j) * k) tmp = 0.0 if (t_2 <= -1e+107) tmp = fma(Float64(-27.0 * k), j, t_1); elseif (t_2 <= 5e+119) tmp = fma(c, b, t_1); else tmp = fma(Float64(-27.0 * k), j, Float64(Float64(x * i) * -4.0)); end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(a * t), $MachinePrecision] * -4.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(27.0 * j), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+107], N[(N[(-27.0 * k), $MachinePrecision] * j + t$95$1), $MachinePrecision], If[LessEqual[t$95$2, 5e+119], N[(c * b + t$95$1), $MachinePrecision], N[(N[(-27.0 * k), $MachinePrecision] * j + N[(N[(x * i), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \left(a \cdot t\right) \cdot -4\\
t_2 := \left(27 \cdot j\right) \cdot k\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+107}:\\
\;\;\;\;\mathsf{fma}\left(-27 \cdot k, j, t\_1\right)\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+119}:\\
\;\;\;\;\mathsf{fma}\left(c, b, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-27 \cdot k, j, \left(x \cdot i\right) \cdot -4\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -9.9999999999999997e106Initial program 89.4%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval89.5
lift--.f64N/A
sub-negN/A
Applied rewrites89.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6469.1
Applied rewrites69.1%
if -9.9999999999999997e106 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 4.9999999999999999e119Initial program 85.3%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites75.1%
Taylor expanded in t around inf
Applied rewrites57.6%
if 4.9999999999999999e119 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 70.1%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval80.6
lift--.f64N/A
sub-negN/A
Applied rewrites87.6%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6467.4
Applied rewrites67.4%
Final simplification61.5%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (* a t) -4.0)) (t_2 (fma c b t_1)))
(if (<= (* c b) -5e+156)
t_2
(if (<= (* c b) 2e-6)
(fma (* -27.0 k) j t_1)
(if (<= (* c b) 5e+242) t_2 (fma (* j -27.0) k (* c b)))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = (a * t) * -4.0;
double t_2 = fma(c, b, t_1);
double tmp;
if ((c * b) <= -5e+156) {
tmp = t_2;
} else if ((c * b) <= 2e-6) {
tmp = fma((-27.0 * k), j, t_1);
} else if ((c * b) <= 5e+242) {
tmp = t_2;
} else {
tmp = fma((j * -27.0), k, (c * b));
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(Float64(a * t) * -4.0) t_2 = fma(c, b, t_1) tmp = 0.0 if (Float64(c * b) <= -5e+156) tmp = t_2; elseif (Float64(c * b) <= 2e-6) tmp = fma(Float64(-27.0 * k), j, t_1); elseif (Float64(c * b) <= 5e+242) tmp = t_2; else tmp = fma(Float64(j * -27.0), k, Float64(c * b)); end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(a * t), $MachinePrecision] * -4.0), $MachinePrecision]}, Block[{t$95$2 = N[(c * b + t$95$1), $MachinePrecision]}, If[LessEqual[N[(c * b), $MachinePrecision], -5e+156], t$95$2, If[LessEqual[N[(c * b), $MachinePrecision], 2e-6], N[(N[(-27.0 * k), $MachinePrecision] * j + t$95$1), $MachinePrecision], If[LessEqual[N[(c * b), $MachinePrecision], 5e+242], t$95$2, N[(N[(j * -27.0), $MachinePrecision] * k + N[(c * b), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \left(a \cdot t\right) \cdot -4\\
t_2 := \mathsf{fma}\left(c, b, t\_1\right)\\
\mathbf{if}\;c \cdot b \leq -5 \cdot 10^{+156}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;c \cdot b \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(-27 \cdot k, j, t\_1\right)\\
\mathbf{elif}\;c \cdot b \leq 5 \cdot 10^{+242}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot -27, k, c \cdot b\right)\\
\end{array}
\end{array}
if (*.f64 b c) < -4.99999999999999992e156 or 1.99999999999999991e-6 < (*.f64 b c) < 5.0000000000000004e242Initial program 80.8%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites82.4%
Taylor expanded in t around inf
Applied rewrites67.1%
if -4.99999999999999992e156 < (*.f64 b c) < 1.99999999999999991e-6Initial program 87.0%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval90.3
lift--.f64N/A
sub-negN/A
Applied rewrites94.9%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6456.8
Applied rewrites56.8%
if 5.0000000000000004e242 < (*.f64 b c) Initial program 61.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6476.9
Applied rewrites76.9%
lift--.f64N/A
lift-*.f64N/A
cancel-sign-sub-invN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites76.9%
Final simplification62.0%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (fma c b (* (* a t) -4.0))))
(if (<= (* 4.0 a) -5e+46)
t_1
(if (<= (* 4.0 a) 1e+17)
(fma (* j -27.0) k (* c b))
(if (<= (* 4.0 a) 2e+89) (fma c b (* (* x i) -4.0)) t_1)))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = fma(c, b, ((a * t) * -4.0));
double tmp;
if ((4.0 * a) <= -5e+46) {
tmp = t_1;
} else if ((4.0 * a) <= 1e+17) {
tmp = fma((j * -27.0), k, (c * b));
} else if ((4.0 * a) <= 2e+89) {
tmp = fma(c, b, ((x * i) * -4.0));
} else {
tmp = t_1;
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = fma(c, b, Float64(Float64(a * t) * -4.0)) tmp = 0.0 if (Float64(4.0 * a) <= -5e+46) tmp = t_1; elseif (Float64(4.0 * a) <= 1e+17) tmp = fma(Float64(j * -27.0), k, Float64(c * b)); elseif (Float64(4.0 * a) <= 2e+89) tmp = fma(c, b, Float64(Float64(x * i) * -4.0)); else tmp = t_1; end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(c * b + N[(N[(a * t), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(4.0 * a), $MachinePrecision], -5e+46], t$95$1, If[LessEqual[N[(4.0 * a), $MachinePrecision], 1e+17], N[(N[(j * -27.0), $MachinePrecision] * k + N[(c * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(4.0 * a), $MachinePrecision], 2e+89], N[(c * b + N[(N[(x * i), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(c, b, \left(a \cdot t\right) \cdot -4\right)\\
\mathbf{if}\;4 \cdot a \leq -5 \cdot 10^{+46}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;4 \cdot a \leq 10^{+17}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot -27, k, c \cdot b\right)\\
\mathbf{elif}\;4 \cdot a \leq 2 \cdot 10^{+89}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \left(x \cdot i\right) \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a #s(literal 4 binary64)) < -5.0000000000000002e46 or 1.99999999999999999e89 < (*.f64 a #s(literal 4 binary64)) Initial program 76.6%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites80.3%
Taylor expanded in t around inf
Applied rewrites62.8%
if -5.0000000000000002e46 < (*.f64 a #s(literal 4 binary64)) < 1e17Initial program 88.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6458.8
Applied rewrites58.8%
lift--.f64N/A
lift-*.f64N/A
cancel-sign-sub-invN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites58.8%
if 1e17 < (*.f64 a #s(literal 4 binary64)) < 1.99999999999999999e89Initial program 75.1%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites87.7%
Taylor expanded in i around inf
Applied rewrites69.7%
Final simplification61.2%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (* 27.0 j) k)))
(if (<= t_1 -1e+265)
(* (* j -27.0) k)
(if (<= t_1 5e+199) (fma c b (* (* a t) -4.0)) (* (* -27.0 k) j)))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = (27.0 * j) * k;
double tmp;
if (t_1 <= -1e+265) {
tmp = (j * -27.0) * k;
} else if (t_1 <= 5e+199) {
tmp = fma(c, b, ((a * t) * -4.0));
} else {
tmp = (-27.0 * k) * j;
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(Float64(27.0 * j) * k) tmp = 0.0 if (t_1 <= -1e+265) tmp = Float64(Float64(j * -27.0) * k); elseif (t_1 <= 5e+199) tmp = fma(c, b, Float64(Float64(a * t) * -4.0)); else tmp = Float64(Float64(-27.0 * k) * j); end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(27.0 * j), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+265], N[(N[(j * -27.0), $MachinePrecision] * k), $MachinePrecision], If[LessEqual[t$95$1, 5e+199], N[(c * b + N[(N[(a * t), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision], N[(N[(-27.0 * k), $MachinePrecision] * j), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \left(27 \cdot j\right) \cdot k\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+265}:\\
\;\;\;\;\left(j \cdot -27\right) \cdot k\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+199}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \left(a \cdot t\right) \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;\left(-27 \cdot k\right) \cdot j\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -1.00000000000000007e265Initial program 86.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f641.6
Applied rewrites1.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6493.4
Applied rewrites93.4%
Applied rewrites93.4%
if -1.00000000000000007e265 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 4.9999999999999998e199Initial program 85.6%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites77.4%
Taylor expanded in t around inf
Applied rewrites54.6%
if 4.9999999999999998e199 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 66.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f649.0
Applied rewrites9.0%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6464.7
Applied rewrites64.7%
Applied rewrites64.8%
Final simplification58.4%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (fma a -4.0 (* (* (* z y) x) 18.0)) t)))
(if (<= t -3.5e+128)
t_1
(if (<= t 2.3e+107)
(fma c b (fma (fma i x (* a t)) -4.0 (* (* j k) -27.0)))
t_1))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = fma(a, -4.0, (((z * y) * x) * 18.0)) * t;
double tmp;
if (t <= -3.5e+128) {
tmp = t_1;
} else if (t <= 2.3e+107) {
tmp = fma(c, b, fma(fma(i, x, (a * t)), -4.0, ((j * k) * -27.0)));
} else {
tmp = t_1;
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(fma(a, -4.0, Float64(Float64(Float64(z * y) * x) * 18.0)) * t) tmp = 0.0 if (t <= -3.5e+128) tmp = t_1; elseif (t <= 2.3e+107) tmp = fma(c, b, fma(fma(i, x, Float64(a * t)), -4.0, Float64(Float64(j * k) * -27.0))); else tmp = t_1; end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(a * -4.0 + N[(N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision] * 18.0), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -3.5e+128], t$95$1, If[LessEqual[t, 2.3e+107], N[(c * b + N[(N[(i * x + N[(a * t), $MachinePrecision]), $MachinePrecision] * -4.0 + N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, -4, \left(\left(z \cdot y\right) \cdot x\right) \cdot 18\right) \cdot t\\
\mathbf{if}\;t \leq -3.5 \cdot 10^{+128}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2.3 \cdot 10^{+107}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(\mathsf{fma}\left(i, x, a \cdot t\right), -4, \left(j \cdot k\right) \cdot -27\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.49999999999999969e128 or 2.3e107 < t Initial program 74.6%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6480.9
Applied rewrites80.9%
if -3.49999999999999969e128 < t < 2.3e107Initial program 87.7%
Taylor expanded in y around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
associate-+r+N/A
distribute-neg-inN/A
distribute-lft-outN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
Applied rewrites87.6%
Final simplification84.9%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (fma a -4.0 (* (* (* z y) x) 18.0)) t)))
(if (<= t -3.2e+48)
t_1
(if (<= t 8.5e+82) (fma c b (fma (* j -27.0) k (* (* x i) -4.0))) t_1))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = fma(a, -4.0, (((z * y) * x) * 18.0)) * t;
double tmp;
if (t <= -3.2e+48) {
tmp = t_1;
} else if (t <= 8.5e+82) {
tmp = fma(c, b, fma((j * -27.0), k, ((x * i) * -4.0)));
} else {
tmp = t_1;
}
return tmp;
}
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(fma(a, -4.0, Float64(Float64(Float64(z * y) * x) * 18.0)) * t) tmp = 0.0 if (t <= -3.2e+48) tmp = t_1; elseif (t <= 8.5e+82) tmp = fma(c, b, fma(Float64(j * -27.0), k, Float64(Float64(x * i) * -4.0))); else tmp = t_1; end return tmp end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(a * -4.0 + N[(N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision] * 18.0), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -3.2e+48], t$95$1, If[LessEqual[t, 8.5e+82], N[(c * b + N[(N[(j * -27.0), $MachinePrecision] * k + N[(N[(x * i), $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, -4, \left(\left(z \cdot y\right) \cdot x\right) \cdot 18\right) \cdot t\\
\mathbf{if}\;t \leq -3.2 \cdot 10^{+48}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{+82}:\\
\;\;\;\;\mathsf{fma}\left(c, b, \mathsf{fma}\left(j \cdot -27, k, \left(x \cdot i\right) \cdot -4\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.2000000000000001e48 or 8.4999999999999995e82 < t Initial program 73.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6477.9
Applied rewrites77.9%
if -3.2000000000000001e48 < t < 8.4999999999999995e82Initial program 90.6%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-*r*N/A
distribute-lft-neg-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6479.0
Applied rewrites79.0%
Final simplification78.5%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. (FPCore (x y z t a b c i j k) :precision binary64 (if (<= (* c b) -5e+156) (* c b) (if (<= (* c b) 2e-6) (* (* j -27.0) k) (* c b))))
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if ((c * b) <= -5e+156) {
tmp = c * b;
} else if ((c * b) <= 2e-6) {
tmp = (j * -27.0) * k;
} else {
tmp = c * b;
}
return tmp;
}
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
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), intent (in) :: k
real(8) :: tmp
if ((c * b) <= (-5d+156)) then
tmp = c * b
else if ((c * b) <= 2d-6) then
tmp = (j * (-27.0d0)) * k
else
tmp = c * b
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if ((c * b) <= -5e+156) {
tmp = c * b;
} else if ((c * b) <= 2e-6) {
tmp = (j * -27.0) * k;
} else {
tmp = c * b;
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): tmp = 0 if (c * b) <= -5e+156: tmp = c * b elif (c * b) <= 2e-6: tmp = (j * -27.0) * k else: tmp = c * b return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (Float64(c * b) <= -5e+156) tmp = Float64(c * b); elseif (Float64(c * b) <= 2e-6) tmp = Float64(Float64(j * -27.0) * k); else tmp = Float64(c * b); end return tmp end
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
tmp = 0.0;
if ((c * b) <= -5e+156)
tmp = c * b;
elseif ((c * b) <= 2e-6)
tmp = (j * -27.0) * k;
else
tmp = c * b;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[N[(c * b), $MachinePrecision], -5e+156], N[(c * b), $MachinePrecision], If[LessEqual[N[(c * b), $MachinePrecision], 2e-6], N[(N[(j * -27.0), $MachinePrecision] * k), $MachinePrecision], N[(c * b), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;c \cdot b \leq -5 \cdot 10^{+156}:\\
\;\;\;\;c \cdot b\\
\mathbf{elif}\;c \cdot b \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\left(j \cdot -27\right) \cdot k\\
\mathbf{else}:\\
\;\;\;\;c \cdot b\\
\end{array}
\end{array}
if (*.f64 b c) < -4.99999999999999992e156 or 1.99999999999999991e-6 < (*.f64 b c) Initial program 76.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6453.2
Applied rewrites53.2%
if -4.99999999999999992e156 < (*.f64 b c) < 1.99999999999999991e-6Initial program 87.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f645.5
Applied rewrites5.5%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6430.5
Applied rewrites30.5%
Applied rewrites30.5%
Final simplification39.7%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. (FPCore (x y z t a b c i j k) :precision binary64 (if (<= (* c b) -5e+156) (* c b) (if (<= (* c b) 2e-6) (* (* j k) -27.0) (* c b))))
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if ((c * b) <= -5e+156) {
tmp = c * b;
} else if ((c * b) <= 2e-6) {
tmp = (j * k) * -27.0;
} else {
tmp = c * b;
}
return tmp;
}
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
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), intent (in) :: k
real(8) :: tmp
if ((c * b) <= (-5d+156)) then
tmp = c * b
else if ((c * b) <= 2d-6) then
tmp = (j * k) * (-27.0d0)
else
tmp = c * b
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if ((c * b) <= -5e+156) {
tmp = c * b;
} else if ((c * b) <= 2e-6) {
tmp = (j * k) * -27.0;
} else {
tmp = c * b;
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): tmp = 0 if (c * b) <= -5e+156: tmp = c * b elif (c * b) <= 2e-6: tmp = (j * k) * -27.0 else: tmp = c * b return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (Float64(c * b) <= -5e+156) tmp = Float64(c * b); elseif (Float64(c * b) <= 2e-6) tmp = Float64(Float64(j * k) * -27.0); else tmp = Float64(c * b); end return tmp end
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k)
tmp = 0.0;
if ((c * b) <= -5e+156)
tmp = c * b;
elseif ((c * b) <= 2e-6)
tmp = (j * k) * -27.0;
else
tmp = c * b;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := If[LessEqual[N[(c * b), $MachinePrecision], -5e+156], N[(c * b), $MachinePrecision], If[LessEqual[N[(c * b), $MachinePrecision], 2e-6], N[(N[(j * k), $MachinePrecision] * -27.0), $MachinePrecision], N[(c * b), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;c \cdot b \leq -5 \cdot 10^{+156}:\\
\;\;\;\;c \cdot b\\
\mathbf{elif}\;c \cdot b \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\left(j \cdot k\right) \cdot -27\\
\mathbf{else}:\\
\;\;\;\;c \cdot b\\
\end{array}
\end{array}
if (*.f64 b c) < -4.99999999999999992e156 or 1.99999999999999991e-6 < (*.f64 b c) Initial program 76.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6453.2
Applied rewrites53.2%
if -4.99999999999999992e156 < (*.f64 b c) < 1.99999999999999991e-6Initial program 87.0%
Taylor expanded in j around inf
lower-*.f64N/A
*-commutativeN/A
lower-*.f6430.5
Applied rewrites30.5%
Final simplification39.7%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. (FPCore (x y z t a b c i j k) :precision binary64 (* c b))
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
return c * b;
}
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b, c, i, j, k)
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), intent (in) :: k
code = c * b
end function
assert x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k;
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
return c * b;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): return c * b
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) return Float64(c * b) end
x, y, z, t, a, b, c, i, j, k = num2cell(sort([x, y, z, t, a, b, c, i, j, k])){:}
function tmp = code(x, y, z, t, a, b, c, i, j, k)
tmp = c * b;
end
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := N[(c * b), $MachinePrecision]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
c \cdot b
\end{array}
Initial program 82.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6424.9
Applied rewrites24.9%
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (+ (* a t) (* i x)) 4.0))
(t_2
(-
(- (* (* 18.0 t) (* (* x y) z)) t_1)
(- (* (* k j) 27.0) (* c b)))))
(if (< t -1.6210815397541398e-69)
t_2
(if (< t 165.68027943805222)
(+ (- (* (* 18.0 y) (* x (* z t))) t_1) (- (* c b) (* 27.0 (* k j))))
t_2))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = ((a * t) + (i * x)) * 4.0;
double t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b));
double tmp;
if (t < -1.6210815397541398e-69) {
tmp = t_2;
} else if (t < 165.68027943805222) {
tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j)));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k)
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), intent (in) :: k
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((a * t) + (i * x)) * 4.0d0
t_2 = (((18.0d0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0d0) - (c * b))
if (t < (-1.6210815397541398d-69)) then
tmp = t_2
else if (t < 165.68027943805222d0) then
tmp = (((18.0d0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0d0 * (k * j)))
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 k) {
double t_1 = ((a * t) + (i * x)) * 4.0;
double t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b));
double tmp;
if (t < -1.6210815397541398e-69) {
tmp = t_2;
} else if (t < 165.68027943805222) {
tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k): t_1 = ((a * t) + (i * x)) * 4.0 t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b)) tmp = 0 if t < -1.6210815397541398e-69: tmp = t_2 elif t < 165.68027943805222: tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(Float64(Float64(a * t) + Float64(i * x)) * 4.0) t_2 = Float64(Float64(Float64(Float64(18.0 * t) * Float64(Float64(x * y) * z)) - t_1) - Float64(Float64(Float64(k * j) * 27.0) - Float64(c * b))) tmp = 0.0 if (t < -1.6210815397541398e-69) tmp = t_2; elseif (t < 165.68027943805222) tmp = Float64(Float64(Float64(Float64(18.0 * y) * Float64(x * Float64(z * t))) - t_1) + Float64(Float64(c * b) - Float64(27.0 * Float64(k * j)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k) t_1 = ((a * t) + (i * x)) * 4.0; t_2 = (((18.0 * t) * ((x * y) * z)) - t_1) - (((k * j) * 27.0) - (c * b)); tmp = 0.0; if (t < -1.6210815397541398e-69) tmp = t_2; elseif (t < 165.68027943805222) tmp = (((18.0 * y) * (x * (z * t))) - t_1) + ((c * b) - (27.0 * (k * j))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_] := Block[{t$95$1 = N[(N[(N[(a * t), $MachinePrecision] + N[(i * x), $MachinePrecision]), $MachinePrecision] * 4.0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(18.0 * t), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision] - N[(N[(N[(k * j), $MachinePrecision] * 27.0), $MachinePrecision] - N[(c * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -1.6210815397541398e-69], t$95$2, If[Less[t, 165.68027943805222], N[(N[(N[(N[(18.0 * y), $MachinePrecision] * N[(x * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision] + N[(N[(c * b), $MachinePrecision] - N[(27.0 * N[(k * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot t + i \cdot x\right) \cdot 4\\
t_2 := \left(\left(18 \cdot t\right) \cdot \left(\left(x \cdot y\right) \cdot z\right) - t\_1\right) - \left(\left(k \cdot j\right) \cdot 27 - c \cdot b\right)\\
\mathbf{if}\;t < -1.6210815397541398 \cdot 10^{-69}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 165.68027943805222:\\
\;\;\;\;\left(\left(18 \cdot y\right) \cdot \left(x \cdot \left(z \cdot t\right)\right) - t\_1\right) + \left(c \cdot b - 27 \cdot \left(k \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024235
(FPCore (x y z t a b c i j k)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, E"
:precision binary64
:alt
(! :herbie-platform default (if (< t -8105407698770699/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (- (* (* 18 t) (* (* x y) z)) (* (+ (* a t) (* i x)) 4)) (- (* (* k j) 27) (* c b))) (if (< t 8284013971902611/50000000000000) (+ (- (* (* 18 y) (* x (* z t))) (* (+ (* a t) (* i x)) 4)) (- (* c b) (* 27 (* k j)))) (- (- (* (* 18 t) (* (* x y) z)) (* (+ (* a t) (* i x)) 4)) (- (* (* k j) 27) (* c b))))))
(- (- (+ (- (* (* (* (* x 18.0) y) z) t) (* (* a 4.0) t)) (* b c)) (* (* x 4.0) i)) (* (* j 27.0) k)))