
(FPCore (x y z t a b) :precision binary64 (+ (- (* x 2.0) (* (* (* y 9.0) z) t)) (* (* a 27.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b);
}
real(8) function code(x, y, z, t, a, b)
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
code = ((x * 2.0d0) - (((y * 9.0d0) * z) * t)) + ((a * 27.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b);
}
def code(x, y, z, t, a, b): return ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x * 2.0) - Float64(Float64(Float64(y * 9.0) * z) * t)) + Float64(Float64(a * 27.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x * 2.0), $MachinePrecision] - N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(N[(a * 27.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot 2 - \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\right) + \left(a \cdot 27\right) \cdot b
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (+ (- (* x 2.0) (* (* (* y 9.0) z) t)) (* (* a 27.0) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b);
}
real(8) function code(x, y, z, t, a, b)
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
code = ((x * 2.0d0) - (((y * 9.0d0) * z) * t)) + ((a * 27.0d0) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b);
}
def code(x, y, z, t, a, b): return ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x * 2.0) - Float64(Float64(Float64(y * 9.0) * z) * t)) + Float64(Float64(a * 27.0) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x * 2.0) - (((y * 9.0) * z) * t)) + ((a * 27.0) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x * 2.0), $MachinePrecision] - N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(N[(a * 27.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot 2 - \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\right) + \left(a \cdot 27\right) \cdot b
\end{array}
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (if (<= z 8.8e-20) (fma (- y) (* (* t z) 9.0) (fma (* b 27.0) a (* 2.0 x))) (fma (* 27.0 a) b (fma (* (* -9.0 y) t) z (* 2.0 x)))))
assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= 8.8e-20) {
tmp = fma(-y, ((t * z) * 9.0), fma((b * 27.0), a, (2.0 * x)));
} else {
tmp = fma((27.0 * a), b, fma(((-9.0 * y) * t), z, (2.0 * x)));
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) tmp = 0.0 if (z <= 8.8e-20) tmp = fma(Float64(-y), Float64(Float64(t * z) * 9.0), fma(Float64(b * 27.0), a, Float64(2.0 * x))); else tmp = fma(Float64(27.0 * a), b, fma(Float64(Float64(-9.0 * y) * t), z, Float64(2.0 * x))); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, 8.8e-20], N[((-y) * N[(N[(t * z), $MachinePrecision] * 9.0), $MachinePrecision] + N[(N[(b * 27.0), $MachinePrecision] * a + N[(2.0 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(27.0 * a), $MachinePrecision] * b + N[(N[(N[(-9.0 * y), $MachinePrecision] * t), $MachinePrecision] * z + N[(2.0 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq 8.8 \cdot 10^{-20}:\\
\;\;\;\;\mathsf{fma}\left(-y, \left(t \cdot z\right) \cdot 9, \mathsf{fma}\left(b \cdot 27, a, 2 \cdot x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(27 \cdot a, b, \mathsf{fma}\left(\left(-9 \cdot y\right) \cdot t, z, 2 \cdot x\right)\right)\\
\end{array}
\end{array}
if z < 8.79999999999999964e-20Initial program 96.6%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites97.2%
if 8.79999999999999964e-20 < z Initial program 89.2%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6492.0
lift-*.f64N/A
*-commutativeN/A
lower-*.f6492.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites98.4%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (* x 2.0) (* (* (* y 9.0) z) t))))
(if (<= t_1 (- INFINITY))
(* (* -9.0 z) (* t y))
(if (<= t_1 -5e+174)
(* 2.0 x)
(if (<= t_1 5e+108)
(* (* b 27.0) a)
(if (<= t_1 1e+293) (* 2.0 x) (* (* (* -9.0 t) z) y)))))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * 2.0) - (((y * 9.0) * z) * t);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (-9.0 * z) * (t * y);
} else if (t_1 <= -5e+174) {
tmp = 2.0 * x;
} else if (t_1 <= 5e+108) {
tmp = (b * 27.0) * a;
} else if (t_1 <= 1e+293) {
tmp = 2.0 * x;
} else {
tmp = ((-9.0 * t) * z) * y;
}
return tmp;
}
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * 2.0) - (((y * 9.0) * z) * t);
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = (-9.0 * z) * (t * y);
} else if (t_1 <= -5e+174) {
tmp = 2.0 * x;
} else if (t_1 <= 5e+108) {
tmp = (b * 27.0) * a;
} else if (t_1 <= 1e+293) {
tmp = 2.0 * x;
} else {
tmp = ((-9.0 * t) * z) * y;
}
return tmp;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): t_1 = (x * 2.0) - (((y * 9.0) * z) * t) tmp = 0 if t_1 <= -math.inf: tmp = (-9.0 * z) * (t * y) elif t_1 <= -5e+174: tmp = 2.0 * x elif t_1 <= 5e+108: tmp = (b * 27.0) * a elif t_1 <= 1e+293: tmp = 2.0 * x else: tmp = ((-9.0 * t) * z) * y return tmp
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * 2.0) - Float64(Float64(Float64(y * 9.0) * z) * t)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(-9.0 * z) * Float64(t * y)); elseif (t_1 <= -5e+174) tmp = Float64(2.0 * x); elseif (t_1 <= 5e+108) tmp = Float64(Float64(b * 27.0) * a); elseif (t_1 <= 1e+293) tmp = Float64(2.0 * x); else tmp = Float64(Float64(Float64(-9.0 * t) * z) * y); end return tmp end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = (x * 2.0) - (((y * 9.0) * z) * t);
tmp = 0.0;
if (t_1 <= -Inf)
tmp = (-9.0 * z) * (t * y);
elseif (t_1 <= -5e+174)
tmp = 2.0 * x;
elseif (t_1 <= 5e+108)
tmp = (b * 27.0) * a;
elseif (t_1 <= 1e+293)
tmp = 2.0 * x;
else
tmp = ((-9.0 * t) * z) * y;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * 2.0), $MachinePrecision] - N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(-9.0 * z), $MachinePrecision] * N[(t * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+174], N[(2.0 * x), $MachinePrecision], If[LessEqual[t$95$1, 5e+108], N[(N[(b * 27.0), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t$95$1, 1e+293], N[(2.0 * x), $MachinePrecision], N[(N[(N[(-9.0 * t), $MachinePrecision] * z), $MachinePrecision] * y), $MachinePrecision]]]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := x \cdot 2 - \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\left(-9 \cdot z\right) \cdot \left(t \cdot y\right)\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+174}:\\
\;\;\;\;2 \cdot x\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+108}:\\
\;\;\;\;\left(b \cdot 27\right) \cdot a\\
\mathbf{elif}\;t\_1 \leq 10^{+293}:\\
\;\;\;\;2 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-9 \cdot t\right) \cdot z\right) \cdot y\\
\end{array}
\end{array}
if (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < -inf.0Initial program 78.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6486.1
lift-*.f64N/A
*-commutativeN/A
lower-*.f6486.1
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites99.8%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6499.8
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites78.7%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6486.1
Applied rewrites86.1%
Applied rewrites96.5%
if -inf.0 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < -4.9999999999999997e174 or 4.99999999999999991e108 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < 9.9999999999999992e292Initial program 99.8%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites90.9%
Taylor expanded in x around inf
lower-*.f6456.6
Applied rewrites56.6%
if -4.9999999999999997e174 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < 4.99999999999999991e108Initial program 99.0%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6480.2
Applied rewrites80.2%
Taylor expanded in x around 0
Applied rewrites54.2%
Applied rewrites54.1%
if 9.9999999999999992e292 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) Initial program 76.2%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6479.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6479.6
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites87.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6487.2
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites82.9%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6483.2
Applied rewrites83.2%
Applied rewrites80.4%
Final simplification62.3%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (* x 2.0) (* (* (* y 9.0) z) t))))
(if (<= t_1 (- INFINITY))
(* (* -9.0 z) (* t y))
(if (<= t_1 -5e+174)
(* 2.0 x)
(if (<= t_1 5e+108)
(* (* b 27.0) a)
(if (<= t_1 1e+293) (* 2.0 x) (* (* t z) (* -9.0 y))))))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * 2.0) - (((y * 9.0) * z) * t);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (-9.0 * z) * (t * y);
} else if (t_1 <= -5e+174) {
tmp = 2.0 * x;
} else if (t_1 <= 5e+108) {
tmp = (b * 27.0) * a;
} else if (t_1 <= 1e+293) {
tmp = 2.0 * x;
} else {
tmp = (t * z) * (-9.0 * y);
}
return tmp;
}
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * 2.0) - (((y * 9.0) * z) * t);
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = (-9.0 * z) * (t * y);
} else if (t_1 <= -5e+174) {
tmp = 2.0 * x;
} else if (t_1 <= 5e+108) {
tmp = (b * 27.0) * a;
} else if (t_1 <= 1e+293) {
tmp = 2.0 * x;
} else {
tmp = (t * z) * (-9.0 * y);
}
return tmp;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): t_1 = (x * 2.0) - (((y * 9.0) * z) * t) tmp = 0 if t_1 <= -math.inf: tmp = (-9.0 * z) * (t * y) elif t_1 <= -5e+174: tmp = 2.0 * x elif t_1 <= 5e+108: tmp = (b * 27.0) * a elif t_1 <= 1e+293: tmp = 2.0 * x else: tmp = (t * z) * (-9.0 * y) return tmp
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * 2.0) - Float64(Float64(Float64(y * 9.0) * z) * t)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(-9.0 * z) * Float64(t * y)); elseif (t_1 <= -5e+174) tmp = Float64(2.0 * x); elseif (t_1 <= 5e+108) tmp = Float64(Float64(b * 27.0) * a); elseif (t_1 <= 1e+293) tmp = Float64(2.0 * x); else tmp = Float64(Float64(t * z) * Float64(-9.0 * y)); end return tmp end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = (x * 2.0) - (((y * 9.0) * z) * t);
tmp = 0.0;
if (t_1 <= -Inf)
tmp = (-9.0 * z) * (t * y);
elseif (t_1 <= -5e+174)
tmp = 2.0 * x;
elseif (t_1 <= 5e+108)
tmp = (b * 27.0) * a;
elseif (t_1 <= 1e+293)
tmp = 2.0 * x;
else
tmp = (t * z) * (-9.0 * y);
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * 2.0), $MachinePrecision] - N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(-9.0 * z), $MachinePrecision] * N[(t * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+174], N[(2.0 * x), $MachinePrecision], If[LessEqual[t$95$1, 5e+108], N[(N[(b * 27.0), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t$95$1, 1e+293], N[(2.0 * x), $MachinePrecision], N[(N[(t * z), $MachinePrecision] * N[(-9.0 * y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := x \cdot 2 - \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\left(-9 \cdot z\right) \cdot \left(t \cdot y\right)\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+174}:\\
\;\;\;\;2 \cdot x\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+108}:\\
\;\;\;\;\left(b \cdot 27\right) \cdot a\\
\mathbf{elif}\;t\_1 \leq 10^{+293}:\\
\;\;\;\;2 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(t \cdot z\right) \cdot \left(-9 \cdot y\right)\\
\end{array}
\end{array}
if (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < -inf.0Initial program 78.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6486.1
lift-*.f64N/A
*-commutativeN/A
lower-*.f6486.1
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites99.8%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6499.8
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites78.7%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6486.1
Applied rewrites86.1%
Applied rewrites96.5%
if -inf.0 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < -4.9999999999999997e174 or 4.99999999999999991e108 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < 9.9999999999999992e292Initial program 99.8%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites90.9%
Taylor expanded in x around inf
lower-*.f6456.6
Applied rewrites56.6%
if -4.9999999999999997e174 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < 4.99999999999999991e108Initial program 99.0%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6480.2
Applied rewrites80.2%
Taylor expanded in x around 0
Applied rewrites54.2%
Applied rewrites54.1%
if 9.9999999999999992e292 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) Initial program 76.2%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6479.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6479.6
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites87.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6487.2
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites82.9%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6483.2
Applied rewrites83.2%
Applied rewrites80.3%
Final simplification62.2%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* -9.0 z) (* t y))) (t_2 (- (* x 2.0) (* (* (* y 9.0) z) t))))
(if (<= t_2 (- INFINITY))
t_1
(if (<= t_2 -5e+174)
(* 2.0 x)
(if (<= t_2 5e+108)
(* (* b 27.0) a)
(if (<= t_2 1e+293) (* 2.0 x) t_1))))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (-9.0 * z) * (t * y);
double t_2 = (x * 2.0) - (((y * 9.0) * z) * t);
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = t_1;
} else if (t_2 <= -5e+174) {
tmp = 2.0 * x;
} else if (t_2 <= 5e+108) {
tmp = (b * 27.0) * a;
} else if (t_2 <= 1e+293) {
tmp = 2.0 * x;
} else {
tmp = t_1;
}
return tmp;
}
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (-9.0 * z) * (t * y);
double t_2 = (x * 2.0) - (((y * 9.0) * z) * t);
double tmp;
if (t_2 <= -Double.POSITIVE_INFINITY) {
tmp = t_1;
} else if (t_2 <= -5e+174) {
tmp = 2.0 * x;
} else if (t_2 <= 5e+108) {
tmp = (b * 27.0) * a;
} else if (t_2 <= 1e+293) {
tmp = 2.0 * x;
} else {
tmp = t_1;
}
return tmp;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): t_1 = (-9.0 * z) * (t * y) t_2 = (x * 2.0) - (((y * 9.0) * z) * t) tmp = 0 if t_2 <= -math.inf: tmp = t_1 elif t_2 <= -5e+174: tmp = 2.0 * x elif t_2 <= 5e+108: tmp = (b * 27.0) * a elif t_2 <= 1e+293: tmp = 2.0 * x else: tmp = t_1 return tmp
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(-9.0 * z) * Float64(t * y)) t_2 = Float64(Float64(x * 2.0) - Float64(Float64(Float64(y * 9.0) * z) * t)) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = t_1; elseif (t_2 <= -5e+174) tmp = Float64(2.0 * x); elseif (t_2 <= 5e+108) tmp = Float64(Float64(b * 27.0) * a); elseif (t_2 <= 1e+293) tmp = Float64(2.0 * x); else tmp = t_1; end return tmp end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = (-9.0 * z) * (t * y);
t_2 = (x * 2.0) - (((y * 9.0) * z) * t);
tmp = 0.0;
if (t_2 <= -Inf)
tmp = t_1;
elseif (t_2 <= -5e+174)
tmp = 2.0 * x;
elseif (t_2 <= 5e+108)
tmp = (b * 27.0) * a;
elseif (t_2 <= 1e+293)
tmp = 2.0 * x;
else
tmp = t_1;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(-9.0 * z), $MachinePrecision] * N[(t * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * 2.0), $MachinePrecision] - N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], t$95$1, If[LessEqual[t$95$2, -5e+174], N[(2.0 * x), $MachinePrecision], If[LessEqual[t$95$2, 5e+108], N[(N[(b * 27.0), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t$95$2, 1e+293], N[(2.0 * x), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(-9 \cdot z\right) \cdot \left(t \cdot y\right)\\
t_2 := x \cdot 2 - \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{+174}:\\
\;\;\;\;2 \cdot x\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+108}:\\
\;\;\;\;\left(b \cdot 27\right) \cdot a\\
\mathbf{elif}\;t\_2 \leq 10^{+293}:\\
\;\;\;\;2 \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < -inf.0 or 9.9999999999999992e292 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) Initial program 77.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6482.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6482.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites93.3%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6493.3
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites80.9%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6484.6
Applied rewrites84.6%
Applied rewrites86.5%
if -inf.0 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < -4.9999999999999997e174 or 4.99999999999999991e108 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < 9.9999999999999992e292Initial program 99.8%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites90.9%
Taylor expanded in x around inf
lower-*.f6456.6
Applied rewrites56.6%
if -4.9999999999999997e174 < (-.f64 (*.f64 x #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t)) < 4.99999999999999991e108Initial program 99.0%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6480.2
Applied rewrites80.2%
Taylor expanded in x around 0
Applied rewrites54.2%
Applied rewrites54.1%
Final simplification61.9%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* (* y 9.0) z) t)))
(if (<= t_1 -200000000.0)
(fma (* (* z -9.0) y) t (* 2.0 x))
(if (<= t_1 2e+14)
(fma 2.0 x (* (* b a) 27.0))
(+ (* -9.0 (* (* z y) t)) (* (* a 27.0) b))))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double tmp;
if (t_1 <= -200000000.0) {
tmp = fma(((z * -9.0) * y), t, (2.0 * x));
} else if (t_1 <= 2e+14) {
tmp = fma(2.0, x, ((b * a) * 27.0));
} else {
tmp = (-9.0 * ((z * y) * t)) + ((a * 27.0) * b);
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(y * 9.0) * z) * t) tmp = 0.0 if (t_1 <= -200000000.0) tmp = fma(Float64(Float64(z * -9.0) * y), t, Float64(2.0 * x)); elseif (t_1 <= 2e+14) tmp = fma(2.0, x, Float64(Float64(b * a) * 27.0)); else tmp = Float64(Float64(-9.0 * Float64(Float64(z * y) * t)) + Float64(Float64(a * 27.0) * b)); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, -200000000.0], N[(N[(N[(z * -9.0), $MachinePrecision] * y), $MachinePrecision] * t + N[(2.0 * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+14], N[(2.0 * x + N[(N[(b * a), $MachinePrecision] * 27.0), $MachinePrecision]), $MachinePrecision], N[(N[(-9.0 * N[(N[(z * y), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(N[(a * 27.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -200000000:\\
\;\;\;\;\mathsf{fma}\left(\left(z \cdot -9\right) \cdot y, t, 2 \cdot x\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(2, x, \left(b \cdot a\right) \cdot 27\right)\\
\mathbf{else}:\\
\;\;\;\;-9 \cdot \left(\left(z \cdot y\right) \cdot t\right) + \left(a \cdot 27\right) \cdot b\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < -2e8Initial program 88.6%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6438.2
Applied rewrites38.2%
Applied rewrites38.2%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6479.1
Applied rewrites79.1%
Applied rewrites80.6%
if -2e8 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < 2e14Initial program 99.1%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6495.0
Applied rewrites95.0%
if 2e14 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) Initial program 90.0%
Taylor expanded in x around 0
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6480.7
Applied rewrites80.7%
Final simplification88.2%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* (* y 9.0) z) t)) (t_2 (* (* b a) 27.0)))
(if (<= t_1 -200000000.0)
(fma (* (* z -9.0) y) t (* 2.0 x))
(if (<= t_1 2e+14) (fma 2.0 x t_2) (fma -9.0 (* (* z y) t) t_2)))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double t_2 = (b * a) * 27.0;
double tmp;
if (t_1 <= -200000000.0) {
tmp = fma(((z * -9.0) * y), t, (2.0 * x));
} else if (t_1 <= 2e+14) {
tmp = fma(2.0, x, t_2);
} else {
tmp = fma(-9.0, ((z * y) * t), t_2);
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(y * 9.0) * z) * t) t_2 = Float64(Float64(b * a) * 27.0) tmp = 0.0 if (t_1 <= -200000000.0) tmp = fma(Float64(Float64(z * -9.0) * y), t, Float64(2.0 * x)); elseif (t_1 <= 2e+14) tmp = fma(2.0, x, t_2); else tmp = fma(-9.0, Float64(Float64(z * y) * t), t_2); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b * a), $MachinePrecision] * 27.0), $MachinePrecision]}, If[LessEqual[t$95$1, -200000000.0], N[(N[(N[(z * -9.0), $MachinePrecision] * y), $MachinePrecision] * t + N[(2.0 * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+14], N[(2.0 * x + t$95$2), $MachinePrecision], N[(-9.0 * N[(N[(z * y), $MachinePrecision] * t), $MachinePrecision] + t$95$2), $MachinePrecision]]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
t_2 := \left(b \cdot a\right) \cdot 27\\
\mathbf{if}\;t\_1 \leq -200000000:\\
\;\;\;\;\mathsf{fma}\left(\left(z \cdot -9\right) \cdot y, t, 2 \cdot x\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+14}:\\
\;\;\;\;\mathsf{fma}\left(2, x, t\_2\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-9, \left(z \cdot y\right) \cdot t, t\_2\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < -2e8Initial program 88.6%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6438.2
Applied rewrites38.2%
Applied rewrites38.2%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6479.1
Applied rewrites79.1%
Applied rewrites80.6%
if -2e8 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < 2e14Initial program 99.1%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6495.0
Applied rewrites95.0%
if 2e14 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) Initial program 90.0%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/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-*.f6480.7
Applied rewrites80.7%
Final simplification88.2%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* (* y 9.0) z) t)))
(if (or (<= t_1 -200000000.0) (not (<= t_1 4e+74)))
(fma (* (* -9.0 y) z) t (* 2.0 x))
(fma (* 27.0 b) a (* x 2.0)))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double tmp;
if ((t_1 <= -200000000.0) || !(t_1 <= 4e+74)) {
tmp = fma(((-9.0 * y) * z), t, (2.0 * x));
} else {
tmp = fma((27.0 * b), a, (x * 2.0));
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(y * 9.0) * z) * t) tmp = 0.0 if ((t_1 <= -200000000.0) || !(t_1 <= 4e+74)) tmp = fma(Float64(Float64(-9.0 * y) * z), t, Float64(2.0 * x)); else tmp = fma(Float64(27.0 * b), a, Float64(x * 2.0)); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -200000000.0], N[Not[LessEqual[t$95$1, 4e+74]], $MachinePrecision]], N[(N[(N[(-9.0 * y), $MachinePrecision] * z), $MachinePrecision] * t + N[(2.0 * x), $MachinePrecision]), $MachinePrecision], N[(N[(27.0 * b), $MachinePrecision] * a + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -200000000 \lor \neg \left(t\_1 \leq 4 \cdot 10^{+74}\right):\\
\;\;\;\;\mathsf{fma}\left(\left(-9 \cdot y\right) \cdot z, t, 2 \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(27 \cdot b, a, x \cdot 2\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < -2e8 or 3.99999999999999981e74 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) Initial program 88.8%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6431.1
Applied rewrites31.1%
Applied rewrites31.2%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6481.7
Applied rewrites81.7%
if -2e8 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < 3.99999999999999981e74Initial program 99.2%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6493.3
Applied rewrites93.3%
Applied rewrites93.3%
Final simplification88.1%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* (* y 9.0) z) t)))
(if (<= t_1 -200000000.0)
(fma (* (* z -9.0) y) t (* 2.0 x))
(if (<= t_1 4e+74)
(fma (* 27.0 b) a (* x 2.0))
(fma (* (* -9.0 y) z) t (* 2.0 x))))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double tmp;
if (t_1 <= -200000000.0) {
tmp = fma(((z * -9.0) * y), t, (2.0 * x));
} else if (t_1 <= 4e+74) {
tmp = fma((27.0 * b), a, (x * 2.0));
} else {
tmp = fma(((-9.0 * y) * z), t, (2.0 * x));
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(y * 9.0) * z) * t) tmp = 0.0 if (t_1 <= -200000000.0) tmp = fma(Float64(Float64(z * -9.0) * y), t, Float64(2.0 * x)); elseif (t_1 <= 4e+74) tmp = fma(Float64(27.0 * b), a, Float64(x * 2.0)); else tmp = fma(Float64(Float64(-9.0 * y) * z), t, Float64(2.0 * x)); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, -200000000.0], N[(N[(N[(z * -9.0), $MachinePrecision] * y), $MachinePrecision] * t + N[(2.0 * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 4e+74], N[(N[(27.0 * b), $MachinePrecision] * a + N[(x * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-9.0 * y), $MachinePrecision] * z), $MachinePrecision] * t + N[(2.0 * x), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -200000000:\\
\;\;\;\;\mathsf{fma}\left(\left(z \cdot -9\right) \cdot y, t, 2 \cdot x\right)\\
\mathbf{elif}\;t\_1 \leq 4 \cdot 10^{+74}:\\
\;\;\;\;\mathsf{fma}\left(27 \cdot b, a, x \cdot 2\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(-9 \cdot y\right) \cdot z, t, 2 \cdot x\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < -2e8Initial program 88.6%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6438.2
Applied rewrites38.2%
Applied rewrites38.2%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6479.1
Applied rewrites79.1%
Applied rewrites80.6%
if -2e8 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < 3.99999999999999981e74Initial program 99.2%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6493.3
Applied rewrites93.3%
Applied rewrites93.3%
if 3.99999999999999981e74 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) Initial program 88.9%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6422.9
Applied rewrites22.9%
Applied rewrites23.0%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6484.8
Applied rewrites84.8%
Final simplification88.4%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* (* y 9.0) z) t)))
(if (<= t_1 -1e+229)
(* (* (* y z) t) -9.0)
(if (<= t_1 5e+100)
(fma (* 27.0 b) a (* x 2.0))
(* (* t z) (* -9.0 y))))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double tmp;
if (t_1 <= -1e+229) {
tmp = ((y * z) * t) * -9.0;
} else if (t_1 <= 5e+100) {
tmp = fma((27.0 * b), a, (x * 2.0));
} else {
tmp = (t * z) * (-9.0 * y);
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(y * 9.0) * z) * t) tmp = 0.0 if (t_1 <= -1e+229) tmp = Float64(Float64(Float64(y * z) * t) * -9.0); elseif (t_1 <= 5e+100) tmp = fma(Float64(27.0 * b), a, Float64(x * 2.0)); else tmp = Float64(Float64(t * z) * Float64(-9.0 * y)); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+229], N[(N[(N[(y * z), $MachinePrecision] * t), $MachinePrecision] * -9.0), $MachinePrecision], If[LessEqual[t$95$1, 5e+100], N[(N[(27.0 * b), $MachinePrecision] * a + N[(x * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(t * z), $MachinePrecision] * N[(-9.0 * y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+229}:\\
\;\;\;\;\left(\left(y \cdot z\right) \cdot t\right) \cdot -9\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+100}:\\
\;\;\;\;\mathsf{fma}\left(27 \cdot b, a, x \cdot 2\right)\\
\mathbf{else}:\\
\;\;\;\;\left(t \cdot z\right) \cdot \left(-9 \cdot y\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < -9.9999999999999999e228Initial program 79.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6482.0
lift-*.f64N/A
*-commutativeN/A
lower-*.f6482.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites86.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6486.0
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites85.0%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6480.4
Applied rewrites80.4%
if -9.9999999999999999e228 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < 4.9999999999999999e100Initial program 99.3%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6486.0
Applied rewrites86.0%
Applied rewrites85.9%
if 4.9999999999999999e100 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) Initial program 87.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6491.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6491.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites97.8%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6497.8
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites87.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6482.4
Applied rewrites82.4%
Applied rewrites78.8%
Final simplification83.9%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* (* y 9.0) z) t)))
(if (<= t_1 -1e+229)
(* (* (* y z) t) -9.0)
(if (<= t_1 5e+100)
(fma 2.0 x (* (* b a) 27.0))
(* (* t z) (* -9.0 y))))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double tmp;
if (t_1 <= -1e+229) {
tmp = ((y * z) * t) * -9.0;
} else if (t_1 <= 5e+100) {
tmp = fma(2.0, x, ((b * a) * 27.0));
} else {
tmp = (t * z) * (-9.0 * y);
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(y * 9.0) * z) * t) tmp = 0.0 if (t_1 <= -1e+229) tmp = Float64(Float64(Float64(y * z) * t) * -9.0); elseif (t_1 <= 5e+100) tmp = fma(2.0, x, Float64(Float64(b * a) * 27.0)); else tmp = Float64(Float64(t * z) * Float64(-9.0 * y)); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+229], N[(N[(N[(y * z), $MachinePrecision] * t), $MachinePrecision] * -9.0), $MachinePrecision], If[LessEqual[t$95$1, 5e+100], N[(2.0 * x + N[(N[(b * a), $MachinePrecision] * 27.0), $MachinePrecision]), $MachinePrecision], N[(N[(t * z), $MachinePrecision] * N[(-9.0 * y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+229}:\\
\;\;\;\;\left(\left(y \cdot z\right) \cdot t\right) \cdot -9\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+100}:\\
\;\;\;\;\mathsf{fma}\left(2, x, \left(b \cdot a\right) \cdot 27\right)\\
\mathbf{else}:\\
\;\;\;\;\left(t \cdot z\right) \cdot \left(-9 \cdot y\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < -9.9999999999999999e228Initial program 79.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6482.0
lift-*.f64N/A
*-commutativeN/A
lower-*.f6482.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites86.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6486.0
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites85.0%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6480.4
Applied rewrites80.4%
if -9.9999999999999999e228 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < 4.9999999999999999e100Initial program 99.3%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6486.0
Applied rewrites86.0%
if 4.9999999999999999e100 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) Initial program 87.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6491.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6491.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites97.8%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6497.8
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites87.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6482.4
Applied rewrites82.4%
Applied rewrites78.8%
Final simplification84.0%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* (* y 9.0) z) t)))
(if (or (<= t_1 -2e-7) (not (<= t_1 5e+81)))
(* (* (* y z) t) -9.0)
(* (* b 27.0) a))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double tmp;
if ((t_1 <= -2e-7) || !(t_1 <= 5e+81)) {
tmp = ((y * z) * t) * -9.0;
} else {
tmp = (b * 27.0) * a;
}
return tmp;
}
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = ((y * 9.0d0) * z) * t
if ((t_1 <= (-2d-7)) .or. (.not. (t_1 <= 5d+81))) then
tmp = ((y * z) * t) * (-9.0d0)
else
tmp = (b * 27.0d0) * a
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((y * 9.0) * z) * t;
double tmp;
if ((t_1 <= -2e-7) || !(t_1 <= 5e+81)) {
tmp = ((y * z) * t) * -9.0;
} else {
tmp = (b * 27.0) * a;
}
return tmp;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): t_1 = ((y * 9.0) * z) * t tmp = 0 if (t_1 <= -2e-7) or not (t_1 <= 5e+81): tmp = ((y * z) * t) * -9.0 else: tmp = (b * 27.0) * a return tmp
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(y * 9.0) * z) * t) tmp = 0.0 if ((t_1 <= -2e-7) || !(t_1 <= 5e+81)) tmp = Float64(Float64(Float64(y * z) * t) * -9.0); else tmp = Float64(Float64(b * 27.0) * a); end return tmp end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = ((y * 9.0) * z) * t;
tmp = 0.0;
if ((t_1 <= -2e-7) || ~((t_1 <= 5e+81)))
tmp = ((y * z) * t) * -9.0;
else
tmp = (b * 27.0) * a;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -2e-7], N[Not[LessEqual[t$95$1, 5e+81]], $MachinePrecision]], N[(N[(N[(y * z), $MachinePrecision] * t), $MachinePrecision] * -9.0), $MachinePrecision], N[(N[(b * 27.0), $MachinePrecision] * a), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{-7} \lor \neg \left(t\_1 \leq 5 \cdot 10^{+81}\right):\\
\;\;\;\;\left(\left(y \cdot z\right) \cdot t\right) \cdot -9\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot 27\right) \cdot a\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < -1.9999999999999999e-7 or 4.9999999999999998e81 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) Initial program 88.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6491.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6491.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites90.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6490.0
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites90.5%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6469.1
Applied rewrites69.1%
if -1.9999999999999999e-7 < (*.f64 (*.f64 (*.f64 y #s(literal 9 binary64)) z) t) < 4.9999999999999998e81Initial program 99.2%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6493.3
Applied rewrites93.3%
Taylor expanded in x around 0
Applied rewrites51.8%
Applied rewrites51.8%
Final simplification59.6%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (let* ((t_1 (* (* a 27.0) b))) (if (or (<= t_1 -2e+83) (not (<= t_1 2e-47))) (* (* a b) 27.0) (* 2.0 x))))
assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a * 27.0) * b;
double tmp;
if ((t_1 <= -2e+83) || !(t_1 <= 2e-47)) {
tmp = (a * b) * 27.0;
} else {
tmp = 2.0 * x;
}
return tmp;
}
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = (a * 27.0d0) * b
if ((t_1 <= (-2d+83)) .or. (.not. (t_1 <= 2d-47))) then
tmp = (a * b) * 27.0d0
else
tmp = 2.0d0 * x
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a * 27.0) * b;
double tmp;
if ((t_1 <= -2e+83) || !(t_1 <= 2e-47)) {
tmp = (a * b) * 27.0;
} else {
tmp = 2.0 * x;
}
return tmp;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): t_1 = (a * 27.0) * b tmp = 0 if (t_1 <= -2e+83) or not (t_1 <= 2e-47): tmp = (a * b) * 27.0 else: tmp = 2.0 * x return tmp
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(a * 27.0) * b) tmp = 0.0 if ((t_1 <= -2e+83) || !(t_1 <= 2e-47)) tmp = Float64(Float64(a * b) * 27.0); else tmp = Float64(2.0 * x); end return tmp end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = (a * 27.0) * b;
tmp = 0.0;
if ((t_1 <= -2e+83) || ~((t_1 <= 2e-47)))
tmp = (a * b) * 27.0;
else
tmp = 2.0 * x;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(a * 27.0), $MachinePrecision] * b), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -2e+83], N[Not[LessEqual[t$95$1, 2e-47]], $MachinePrecision]], N[(N[(a * b), $MachinePrecision] * 27.0), $MachinePrecision], N[(2.0 * x), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(a \cdot 27\right) \cdot b\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+83} \lor \neg \left(t\_1 \leq 2 \cdot 10^{-47}\right):\\
\;\;\;\;\left(a \cdot b\right) \cdot 27\\
\mathbf{else}:\\
\;\;\;\;2 \cdot x\\
\end{array}
\end{array}
if (*.f64 (*.f64 a #s(literal 27 binary64)) b) < -2.00000000000000006e83 or 1.9999999999999999e-47 < (*.f64 (*.f64 a #s(literal 27 binary64)) b) Initial program 92.3%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6470.8
Applied rewrites70.8%
Taylor expanded in x around 0
Applied rewrites60.4%
if -2.00000000000000006e83 < (*.f64 (*.f64 a #s(literal 27 binary64)) b) < 1.9999999999999999e-47Initial program 96.8%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites95.3%
Taylor expanded in x around inf
lower-*.f6451.3
Applied rewrites51.3%
Final simplification56.0%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (let* ((t_1 (* (* a 27.0) b))) (if (or (<= t_1 -2e+83) (not (<= t_1 2e-47))) (* (* 27.0 a) b) (* 2.0 x))))
assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a * 27.0) * b;
double tmp;
if ((t_1 <= -2e+83) || !(t_1 <= 2e-47)) {
tmp = (27.0 * a) * b;
} else {
tmp = 2.0 * x;
}
return tmp;
}
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = (a * 27.0d0) * b
if ((t_1 <= (-2d+83)) .or. (.not. (t_1 <= 2d-47))) then
tmp = (27.0d0 * a) * b
else
tmp = 2.0d0 * x
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a * 27.0) * b;
double tmp;
if ((t_1 <= -2e+83) || !(t_1 <= 2e-47)) {
tmp = (27.0 * a) * b;
} else {
tmp = 2.0 * x;
}
return tmp;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): t_1 = (a * 27.0) * b tmp = 0 if (t_1 <= -2e+83) or not (t_1 <= 2e-47): tmp = (27.0 * a) * b else: tmp = 2.0 * x return tmp
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(a * 27.0) * b) tmp = 0.0 if ((t_1 <= -2e+83) || !(t_1 <= 2e-47)) tmp = Float64(Float64(27.0 * a) * b); else tmp = Float64(2.0 * x); end return tmp end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = (a * 27.0) * b;
tmp = 0.0;
if ((t_1 <= -2e+83) || ~((t_1 <= 2e-47)))
tmp = (27.0 * a) * b;
else
tmp = 2.0 * x;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(a * 27.0), $MachinePrecision] * b), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -2e+83], N[Not[LessEqual[t$95$1, 2e-47]], $MachinePrecision]], N[(N[(27.0 * a), $MachinePrecision] * b), $MachinePrecision], N[(2.0 * x), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(a \cdot 27\right) \cdot b\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+83} \lor \neg \left(t\_1 \leq 2 \cdot 10^{-47}\right):\\
\;\;\;\;\left(27 \cdot a\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;2 \cdot x\\
\end{array}
\end{array}
if (*.f64 (*.f64 a #s(literal 27 binary64)) b) < -2.00000000000000006e83 or 1.9999999999999999e-47 < (*.f64 (*.f64 a #s(literal 27 binary64)) b) Initial program 92.3%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6470.8
Applied rewrites70.8%
Taylor expanded in x around 0
Applied rewrites60.4%
Applied rewrites60.4%
if -2.00000000000000006e83 < (*.f64 (*.f64 a #s(literal 27 binary64)) b) < 1.9999999999999999e-47Initial program 96.8%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites95.3%
Taylor expanded in x around inf
lower-*.f6451.3
Applied rewrites51.3%
Final simplification55.9%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (* a 27.0) b)))
(if (<= t_1 -2e+83)
(* (* b 27.0) a)
(if (<= t_1 2e-47) (* 2.0 x) (* (* a b) 27.0)))))assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a * 27.0) * b;
double tmp;
if (t_1 <= -2e+83) {
tmp = (b * 27.0) * a;
} else if (t_1 <= 2e-47) {
tmp = 2.0 * x;
} else {
tmp = (a * b) * 27.0;
}
return tmp;
}
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = (a * 27.0d0) * b
if (t_1 <= (-2d+83)) then
tmp = (b * 27.0d0) * a
else if (t_1 <= 2d-47) then
tmp = 2.0d0 * x
else
tmp = (a * b) * 27.0d0
end if
code = tmp
end function
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (a * 27.0) * b;
double tmp;
if (t_1 <= -2e+83) {
tmp = (b * 27.0) * a;
} else if (t_1 <= 2e-47) {
tmp = 2.0 * x;
} else {
tmp = (a * b) * 27.0;
}
return tmp;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): t_1 = (a * 27.0) * b tmp = 0 if t_1 <= -2e+83: tmp = (b * 27.0) * a elif t_1 <= 2e-47: tmp = 2.0 * x else: tmp = (a * b) * 27.0 return tmp
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) t_1 = Float64(Float64(a * 27.0) * b) tmp = 0.0 if (t_1 <= -2e+83) tmp = Float64(Float64(b * 27.0) * a); elseif (t_1 <= 2e-47) tmp = Float64(2.0 * x); else tmp = Float64(Float64(a * b) * 27.0); end return tmp end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp_2 = code(x, y, z, t, a, b)
t_1 = (a * 27.0) * b;
tmp = 0.0;
if (t_1 <= -2e+83)
tmp = (b * 27.0) * a;
elseif (t_1 <= 2e-47)
tmp = 2.0 * x;
else
tmp = (a * b) * 27.0;
end
tmp_2 = tmp;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(a * 27.0), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+83], N[(N[(b * 27.0), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t$95$1, 2e-47], N[(2.0 * x), $MachinePrecision], N[(N[(a * b), $MachinePrecision] * 27.0), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
t_1 := \left(a \cdot 27\right) \cdot b\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+83}:\\
\;\;\;\;\left(b \cdot 27\right) \cdot a\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-47}:\\
\;\;\;\;2 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot b\right) \cdot 27\\
\end{array}
\end{array}
if (*.f64 (*.f64 a #s(literal 27 binary64)) b) < -2.00000000000000006e83Initial program 93.0%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6474.6
Applied rewrites74.6%
Taylor expanded in x around 0
Applied rewrites68.7%
Applied rewrites68.6%
if -2.00000000000000006e83 < (*.f64 (*.f64 a #s(literal 27 binary64)) b) < 1.9999999999999999e-47Initial program 96.8%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites95.3%
Taylor expanded in x around inf
lower-*.f6451.3
Applied rewrites51.3%
if 1.9999999999999999e-47 < (*.f64 (*.f64 a #s(literal 27 binary64)) b) Initial program 91.7%
Taylor expanded in y around 0
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6467.8
Applied rewrites67.8%
Taylor expanded in x around 0
Applied rewrites53.7%
Final simplification56.0%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (if (<= z -2.1e+59) (fma (* 27.0 a) b (fma (* (* -9.0 y) t) z (* 2.0 x))) (fma (* (* z y) t) -9.0 (fma a (* 27.0 b) (* x 2.0)))))
assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= -2.1e+59) {
tmp = fma((27.0 * a), b, fma(((-9.0 * y) * t), z, (2.0 * x)));
} else {
tmp = fma(((z * y) * t), -9.0, fma(a, (27.0 * b), (x * 2.0)));
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) tmp = 0.0 if (z <= -2.1e+59) tmp = fma(Float64(27.0 * a), b, fma(Float64(Float64(-9.0 * y) * t), z, Float64(2.0 * x))); else tmp = fma(Float64(Float64(z * y) * t), -9.0, fma(a, Float64(27.0 * b), Float64(x * 2.0))); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -2.1e+59], N[(N[(27.0 * a), $MachinePrecision] * b + N[(N[(N[(-9.0 * y), $MachinePrecision] * t), $MachinePrecision] * z + N[(2.0 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z * y), $MachinePrecision] * t), $MachinePrecision] * -9.0 + N[(a * N[(27.0 * b), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.1 \cdot 10^{+59}:\\
\;\;\;\;\mathsf{fma}\left(27 \cdot a, b, \mathsf{fma}\left(\left(-9 \cdot y\right) \cdot t, z, 2 \cdot x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\left(z \cdot y\right) \cdot t, -9, \mathsf{fma}\left(a, 27 \cdot b, x \cdot 2\right)\right)\\
\end{array}
\end{array}
if z < -2.09999999999999984e59Initial program 90.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6493.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6493.2
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites97.8%
if -2.09999999999999984e59 < z Initial program 95.2%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6496.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6496.2
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites94.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f6494.5
lower-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-fma.f64N/A
associate-+l+N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites96.2%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (if (<= z 8.8e-20) (fma (* t z) (* -9.0 y) (fma (* b 27.0) a (* 2.0 x))) (fma (* 27.0 a) b (fma (* (* -9.0 y) t) z (* 2.0 x)))))
assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= 8.8e-20) {
tmp = fma((t * z), (-9.0 * y), fma((b * 27.0), a, (2.0 * x)));
} else {
tmp = fma((27.0 * a), b, fma(((-9.0 * y) * t), z, (2.0 * x)));
}
return tmp;
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) tmp = 0.0 if (z <= 8.8e-20) tmp = fma(Float64(t * z), Float64(-9.0 * y), fma(Float64(b * 27.0), a, Float64(2.0 * x))); else tmp = fma(Float64(27.0 * a), b, fma(Float64(Float64(-9.0 * y) * t), z, Float64(2.0 * x))); end return tmp end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, 8.8e-20], N[(N[(t * z), $MachinePrecision] * N[(-9.0 * y), $MachinePrecision] + N[(N[(b * 27.0), $MachinePrecision] * a + N[(2.0 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(27.0 * a), $MachinePrecision] * b + N[(N[(N[(-9.0 * y), $MachinePrecision] * t), $MachinePrecision] * z + N[(2.0 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\begin{array}{l}
\mathbf{if}\;z \leq 8.8 \cdot 10^{-20}:\\
\;\;\;\;\mathsf{fma}\left(t \cdot z, -9 \cdot y, \mathsf{fma}\left(b \cdot 27, a, 2 \cdot x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(27 \cdot a, b, \mathsf{fma}\left(\left(-9 \cdot y\right) \cdot t, z, 2 \cdot x\right)\right)\\
\end{array}
\end{array}
if z < 8.79999999999999964e-20Initial program 96.6%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-evalN/A
Applied rewrites96.7%
if 8.79999999999999964e-20 < z Initial program 89.2%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6492.0
lift-*.f64N/A
*-commutativeN/A
lower-*.f6492.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites98.4%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (fma (* 27.0 a) b (fma (* (* -9.0 y) t) z (* 2.0 x))))
assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
return fma((27.0 * a), b, fma(((-9.0 * y) * t), z, (2.0 * x)));
}
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) return fma(Float64(27.0 * a), b, fma(Float64(Float64(-9.0 * y) * t), z, Float64(2.0 * x))) end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := N[(N[(27.0 * a), $MachinePrecision] * b + N[(N[(N[(-9.0 * y), $MachinePrecision] * t), $MachinePrecision] * z + N[(2.0 * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
\mathsf{fma}\left(27 \cdot a, b, \mathsf{fma}\left(\left(-9 \cdot y\right) \cdot t, z, 2 \cdot x\right)\right)
\end{array}
Initial program 94.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6495.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6495.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites95.0%
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. (FPCore (x y z t a b) :precision binary64 (* 2.0 x))
assert(x < y && y < z && z < t && t < a && a < b);
assert(x < y && y < z && z < t && t < a && a < b);
double code(double x, double y, double z, double t, double a, double b) {
return 2.0 * x;
}
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, t, a, b)
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
code = 2.0d0 * x
end function
assert x < y && y < z && z < t && t < a && a < b;
assert x < y && y < z && z < t && t < a && a < b;
public static double code(double x, double y, double z, double t, double a, double b) {
return 2.0 * x;
}
[x, y, z, t, a, b] = sort([x, y, z, t, a, b]) [x, y, z, t, a, b] = sort([x, y, z, t, a, b]) def code(x, y, z, t, a, b): return 2.0 * x
x, y, z, t, a, b = sort([x, y, z, t, a, b]) x, y, z, t, a, b = sort([x, y, z, t, a, b]) function code(x, y, z, t, a, b) return Float64(2.0 * x) end
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
x, y, z, t, a, b = num2cell(sort([x, y, z, t, a, b])){:}
function tmp = code(x, y, z, t, a, b)
tmp = 2.0 * x;
end
NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. NOTE: x, y, z, t, a, and b should be sorted in increasing order before calling this function. code[x_, y_, z_, t_, a_, b_] := N[(2.0 * x), $MachinePrecision]
\begin{array}{l}
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\\\
[x, y, z, t, a, b] = \mathsf{sort}([x, y, z, t, a, b])\\
\\
2 \cdot x
\end{array}
Initial program 94.5%
lift-+.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
+-commutativeN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites94.7%
Taylor expanded in x around inf
lower-*.f6430.7
Applied rewrites30.7%
(FPCore (x y z t a b) :precision binary64 (if (< y 7.590524218811189e-161) (+ (- (* x 2.0) (* (* (* y 9.0) z) t)) (* a (* 27.0 b))) (+ (- (* x 2.0) (* 9.0 (* y (* t z)))) (* (* a 27.0) b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y < 7.590524218811189e-161) {
tmp = ((x * 2.0) - (((y * 9.0) * z) * t)) + (a * (27.0 * b));
} else {
tmp = ((x * 2.0) - (9.0 * (y * (t * z)))) + ((a * 27.0) * b);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (y < 7.590524218811189d-161) then
tmp = ((x * 2.0d0) - (((y * 9.0d0) * z) * t)) + (a * (27.0d0 * b))
else
tmp = ((x * 2.0d0) - (9.0d0 * (y * (t * z)))) + ((a * 27.0d0) * b)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y < 7.590524218811189e-161) {
tmp = ((x * 2.0) - (((y * 9.0) * z) * t)) + (a * (27.0 * b));
} else {
tmp = ((x * 2.0) - (9.0 * (y * (t * z)))) + ((a * 27.0) * b);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y < 7.590524218811189e-161: tmp = ((x * 2.0) - (((y * 9.0) * z) * t)) + (a * (27.0 * b)) else: tmp = ((x * 2.0) - (9.0 * (y * (t * z)))) + ((a * 27.0) * b) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y < 7.590524218811189e-161) tmp = Float64(Float64(Float64(x * 2.0) - Float64(Float64(Float64(y * 9.0) * z) * t)) + Float64(a * Float64(27.0 * b))); else tmp = Float64(Float64(Float64(x * 2.0) - Float64(9.0 * Float64(y * Float64(t * z)))) + Float64(Float64(a * 27.0) * b)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y < 7.590524218811189e-161) tmp = ((x * 2.0) - (((y * 9.0) * z) * t)) + (a * (27.0 * b)); else tmp = ((x * 2.0) - (9.0 * (y * (t * z)))) + ((a * 27.0) * b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Less[y, 7.590524218811189e-161], N[(N[(N[(x * 2.0), $MachinePrecision] - N[(N[(N[(y * 9.0), $MachinePrecision] * z), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(27.0 * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * 2.0), $MachinePrecision] - N[(9.0 * N[(y * N[(t * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(a * 27.0), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y < 7.590524218811189 \cdot 10^{-161}:\\
\;\;\;\;\left(x \cdot 2 - \left(\left(y \cdot 9\right) \cdot z\right) \cdot t\right) + a \cdot \left(27 \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot 2 - 9 \cdot \left(y \cdot \left(t \cdot z\right)\right)\right) + \left(a \cdot 27\right) \cdot b\\
\end{array}
\end{array}
herbie shell --seed 2024313
(FPCore (x y z t a b)
:name "Diagrams.Solve.Polynomial:cubForm from diagrams-solve-0.1, A"
:precision binary64
:alt
(! :herbie-platform default (if (< y 7590524218811189/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x 2) (* (* (* y 9) z) t)) (* a (* 27 b))) (+ (- (* x 2) (* 9 (* y (* t z)))) (* (* a 27) b))))
(+ (- (* x 2.0) (* (* (* y 9.0) z) t)) (* (* a 27.0) b)))