
(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 21 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
(let* ((t_1 (* (* (* x 18.0) y) z))
(t_2 (* (* j 27.0) k))
(t_3 (* 18.0 (* y z)))
(t_4 (- (+ (- (* t_1 t) (* t (* a 4.0))) (* b c)) (* (* x 4.0) i))))
(if (<= t_4 (- INFINITY))
(-
(*
y
(+
(* 18.0 (* x (* z t)))
(/ (+ (* b c) (* -4.0 (+ (* t a) (* x i)))) y)))
t_2)
(if (<= t_4 5e+306)
(+
(* t (+ t_1 (* a -4.0)))
(+ (* -27.0 (* j k)) (+ (* b c) (* x (* i -4.0)))))
(if (<= t_4 INFINITY)
(-
(* x (+ (+ (* i -4.0) (* t t_3)) (/ (+ (* b c) (* t (* a -4.0))) x)))
t_2)
(* t (+ (* a -4.0) (* x t_3))))))))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 = ((x * 18.0) * y) * z;
double t_2 = (j * 27.0) * k;
double t_3 = 18.0 * (y * z);
double t_4 = (((t_1 * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i);
double tmp;
if (t_4 <= -((double) INFINITY)) {
tmp = (y * ((18.0 * (x * (z * t))) + (((b * c) + (-4.0 * ((t * a) + (x * i)))) / y))) - t_2;
} else if (t_4 <= 5e+306) {
tmp = (t * (t_1 + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else if (t_4 <= ((double) INFINITY)) {
tmp = (x * (((i * -4.0) + (t * t_3)) + (((b * c) + (t * (a * -4.0))) / x))) - t_2;
} else {
tmp = t * ((a * -4.0) + (x * t_3));
}
return tmp;
}
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 = ((x * 18.0) * y) * z;
double t_2 = (j * 27.0) * k;
double t_3 = 18.0 * (y * z);
double t_4 = (((t_1 * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i);
double tmp;
if (t_4 <= -Double.POSITIVE_INFINITY) {
tmp = (y * ((18.0 * (x * (z * t))) + (((b * c) + (-4.0 * ((t * a) + (x * i)))) / y))) - t_2;
} else if (t_4 <= 5e+306) {
tmp = (t * (t_1 + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else if (t_4 <= Double.POSITIVE_INFINITY) {
tmp = (x * (((i * -4.0) + (t * t_3)) + (((b * c) + (t * (a * -4.0))) / x))) - t_2;
} else {
tmp = t * ((a * -4.0) + (x * t_3));
}
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 = ((x * 18.0) * y) * z t_2 = (j * 27.0) * k t_3 = 18.0 * (y * z) t_4 = (((t_1 * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i) tmp = 0 if t_4 <= -math.inf: tmp = (y * ((18.0 * (x * (z * t))) + (((b * c) + (-4.0 * ((t * a) + (x * i)))) / y))) - t_2 elif t_4 <= 5e+306: tmp = (t * (t_1 + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) elif t_4 <= math.inf: tmp = (x * (((i * -4.0) + (t * t_3)) + (((b * c) + (t * (a * -4.0))) / x))) - t_2 else: tmp = t * ((a * -4.0) + (x * t_3)) 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(Float64(x * 18.0) * y) * z) t_2 = Float64(Float64(j * 27.0) * k) t_3 = Float64(18.0 * Float64(y * z)) t_4 = Float64(Float64(Float64(Float64(t_1 * t) - Float64(t * Float64(a * 4.0))) + Float64(b * c)) - Float64(Float64(x * 4.0) * i)) tmp = 0.0 if (t_4 <= Float64(-Inf)) tmp = Float64(Float64(y * Float64(Float64(18.0 * Float64(x * Float64(z * t))) + Float64(Float64(Float64(b * c) + Float64(-4.0 * Float64(Float64(t * a) + Float64(x * i)))) / y))) - t_2); elseif (t_4 <= 5e+306) tmp = Float64(Float64(t * Float64(t_1 + Float64(a * -4.0))) + Float64(Float64(-27.0 * Float64(j * k)) + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))))); elseif (t_4 <= Inf) tmp = Float64(Float64(x * Float64(Float64(Float64(i * -4.0) + Float64(t * t_3)) + Float64(Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))) / x))) - t_2); else tmp = Float64(t * Float64(Float64(a * -4.0) + Float64(x * t_3))); 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 = ((x * 18.0) * y) * z;
t_2 = (j * 27.0) * k;
t_3 = 18.0 * (y * z);
t_4 = (((t_1 * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i);
tmp = 0.0;
if (t_4 <= -Inf)
tmp = (y * ((18.0 * (x * (z * t))) + (((b * c) + (-4.0 * ((t * a) + (x * i)))) / y))) - t_2;
elseif (t_4 <= 5e+306)
tmp = (t * (t_1 + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
elseif (t_4 <= Inf)
tmp = (x * (((i * -4.0) + (t * t_3)) + (((b * c) + (t * (a * -4.0))) / x))) - t_2;
else
tmp = t * ((a * -4.0) + (x * t_3));
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[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$3 = N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(t$95$1 * t), $MachinePrecision] - N[(t * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * c), $MachinePrecision]), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, (-Infinity)], N[(N[(y * N[(N[(18.0 * N[(x * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(N[(t * a), $MachinePrecision] + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 5e+306], N[(N[(t * N[(t$95$1 + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[(x * N[(N[(N[(i * -4.0), $MachinePrecision] + N[(t * t$95$3), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$2), $MachinePrecision], N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(x * t$95$3), $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}
t_1 := \left(\left(x \cdot 18\right) \cdot y\right) \cdot z\\
t_2 := \left(j \cdot 27\right) \cdot k\\
t_3 := 18 \cdot \left(y \cdot z\right)\\
t_4 := \left(\left(t\_1 \cdot t - t \cdot \left(a \cdot 4\right)\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\\
\mathbf{if}\;t\_4 \leq -\infty:\\
\;\;\;\;y \cdot \left(18 \cdot \left(x \cdot \left(z \cdot t\right)\right) + \frac{b \cdot c + -4 \cdot \left(t \cdot a + x \cdot i\right)}{y}\right) - t\_2\\
\mathbf{elif}\;t\_4 \leq 5 \cdot 10^{+306}:\\
\;\;\;\;t \cdot \left(t\_1 + a \cdot -4\right) + \left(-27 \cdot \left(j \cdot k\right) + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right)\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;x \cdot \left(\left(i \cdot -4 + t \cdot t\_3\right) + \frac{b \cdot c + t \cdot \left(a \cdot -4\right)}{x}\right) - t\_2\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(a \cdot -4 + x \cdot t\_3\right)\\
\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)) < -inf.0Initial program 80.7%
Taylor expanded in y around inf
*-lowering-*.f64N/A
associate--l+N/A
associate--r+N/A
associate-*r/N/A
div-subN/A
associate-*r/N/A
div-subN/A
associate--r+N/A
+-lowering-+.f64N/A
Simplified89.1%
if -inf.0 < (-.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.8%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified99.8%
if 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)) < +inf.0Initial program 72.9%
Taylor expanded in x around inf
Simplified90.6%
if +inf.0 < (-.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 0.0%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified25.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6467.1%
Simplified67.1%
Final simplification92.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
(-
(*
x
(+
(+ (* i -4.0) (* t (* 18.0 (* y z))))
(/ (+ (* b c) (* t (* a -4.0))) x)))
(* (* j 27.0) k))))
(if (<= x -2.5e+106)
t_1
(if (<= x 1.2e+39)
(+
(* t (+ (* (* (* x 18.0) y) z) (* a -4.0)))
(+ (* -27.0 (* j k)) (+ (* b c) (* 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 = (x * (((i * -4.0) + (t * (18.0 * (y * z)))) + (((b * c) + (t * (a * -4.0))) / x))) - ((j * 27.0) * k);
double tmp;
if (x <= -2.5e+106) {
tmp = t_1;
} else if (x <= 1.2e+39) {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else {
tmp = t_1;
}
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 = (x * (((i * (-4.0d0)) + (t * (18.0d0 * (y * z)))) + (((b * c) + (t * (a * (-4.0d0)))) / x))) - ((j * 27.0d0) * k)
if (x <= (-2.5d+106)) then
tmp = t_1
else if (x <= 1.2d+39) then
tmp = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + (((-27.0d0) * (j * k)) + ((b * c) + (x * (i * (-4.0d0)))))
else
tmp = t_1
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 = (x * (((i * -4.0) + (t * (18.0 * (y * z)))) + (((b * c) + (t * (a * -4.0))) / x))) - ((j * 27.0) * k);
double tmp;
if (x <= -2.5e+106) {
tmp = t_1;
} else if (x <= 1.2e+39) {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = (x * (((i * -4.0) + (t * (18.0 * (y * z)))) + (((b * c) + (t * (a * -4.0))) / x))) - ((j * 27.0) * k) tmp = 0 if x <= -2.5e+106: tmp = t_1 elif x <= 1.2e+39: tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (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(Float64(x * Float64(Float64(Float64(i * -4.0) + Float64(t * Float64(18.0 * Float64(y * z)))) + Float64(Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))) / x))) - Float64(Float64(j * 27.0) * k)) tmp = 0.0 if (x <= -2.5e+106) tmp = t_1; elseif (x <= 1.2e+39) tmp = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + Float64(Float64(-27.0 * Float64(j * k)) + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))))); else tmp = t_1; 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 = (x * (((i * -4.0) + (t * (18.0 * (y * z)))) + (((b * c) + (t * (a * -4.0))) / x))) - ((j * 27.0) * k);
tmp = 0.0;
if (x <= -2.5e+106)
tmp = t_1;
elseif (x <= 1.2e+39)
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
else
tmp = t_1;
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[(x * N[(N[(N[(i * -4.0), $MachinePrecision] + N[(t * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.5e+106], t$95$1, If[LessEqual[x, 1.2e+39], N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $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 := x \cdot \left(\left(i \cdot -4 + t \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right) + \frac{b \cdot c + t \cdot \left(a \cdot -4\right)}{x}\right) - \left(j \cdot 27\right) \cdot k\\
\mathbf{if}\;x \leq -2.5 \cdot 10^{+106}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.2 \cdot 10^{+39}:\\
\;\;\;\;t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + \left(-27 \cdot \left(j \cdot k\right) + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.4999999999999999e106 or 1.2e39 < x Initial program 66.2%
Taylor expanded in x around inf
Simplified87.8%
if -2.4999999999999999e106 < x < 1.2e39Initial program 91.1%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified92.4%
Final simplification90.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
(let* ((t_1 (* (* j 27.0) k)))
(if (<= t_1 -1e+140)
(+ (* t (* a -4.0)) (* j (* k -27.0)))
(if (<= t_1 -2e+100)
(* (* z (* 18.0 y)) (* x t))
(if (<= t_1 1e+149)
(+ (* b c) (* -4.0 (+ (* t a) (* x i))))
(- (* b c) 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 = (j * 27.0) * k;
double tmp;
if (t_1 <= -1e+140) {
tmp = (t * (a * -4.0)) + (j * (k * -27.0));
} else if (t_1 <= -2e+100) {
tmp = (z * (18.0 * y)) * (x * t);
} else if (t_1 <= 1e+149) {
tmp = (b * c) + (-4.0 * ((t * a) + (x * i)));
} else {
tmp = (b * c) - t_1;
}
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 = (j * 27.0d0) * k
if (t_1 <= (-1d+140)) then
tmp = (t * (a * (-4.0d0))) + (j * (k * (-27.0d0)))
else if (t_1 <= (-2d+100)) then
tmp = (z * (18.0d0 * y)) * (x * t)
else if (t_1 <= 1d+149) then
tmp = (b * c) + ((-4.0d0) * ((t * a) + (x * i)))
else
tmp = (b * c) - t_1
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 = (j * 27.0) * k;
double tmp;
if (t_1 <= -1e+140) {
tmp = (t * (a * -4.0)) + (j * (k * -27.0));
} else if (t_1 <= -2e+100) {
tmp = (z * (18.0 * y)) * (x * t);
} else if (t_1 <= 1e+149) {
tmp = (b * c) + (-4.0 * ((t * a) + (x * i)));
} else {
tmp = (b * c) - 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = (j * 27.0) * k tmp = 0 if t_1 <= -1e+140: tmp = (t * (a * -4.0)) + (j * (k * -27.0)) elif t_1 <= -2e+100: tmp = (z * (18.0 * y)) * (x * t) elif t_1 <= 1e+149: tmp = (b * c) + (-4.0 * ((t * a) + (x * i))) else: tmp = (b * c) - 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(Float64(j * 27.0) * k) tmp = 0.0 if (t_1 <= -1e+140) tmp = Float64(Float64(t * Float64(a * -4.0)) + Float64(j * Float64(k * -27.0))); elseif (t_1 <= -2e+100) tmp = Float64(Float64(z * Float64(18.0 * y)) * Float64(x * t)); elseif (t_1 <= 1e+149) tmp = Float64(Float64(b * c) + Float64(-4.0 * Float64(Float64(t * a) + Float64(x * i)))); else tmp = Float64(Float64(b * c) - t_1); 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 = (j * 27.0) * k;
tmp = 0.0;
if (t_1 <= -1e+140)
tmp = (t * (a * -4.0)) + (j * (k * -27.0));
elseif (t_1 <= -2e+100)
tmp = (z * (18.0 * y)) * (x * t);
elseif (t_1 <= 1e+149)
tmp = (b * c) + (-4.0 * ((t * a) + (x * i)));
else
tmp = (b * c) - t_1;
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[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+140], N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] + N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -2e+100], N[(N[(z * N[(18.0 * y), $MachinePrecision]), $MachinePrecision] * N[(x * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+149], N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(N[(t * a), $MachinePrecision] + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b * c), $MachinePrecision] - t$95$1), $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(j \cdot 27\right) \cdot k\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+140}:\\
\;\;\;\;t \cdot \left(a \cdot -4\right) + j \cdot \left(k \cdot -27\right)\\
\mathbf{elif}\;t\_1 \leq -2 \cdot 10^{+100}:\\
\;\;\;\;\left(z \cdot \left(18 \cdot y\right)\right) \cdot \left(x \cdot t\right)\\
\mathbf{elif}\;t\_1 \leq 10^{+149}:\\
\;\;\;\;b \cdot c + -4 \cdot \left(t \cdot a + x \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot c - t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -1.00000000000000006e140Initial program 74.0%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified79.3%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6481.8%
Simplified81.8%
Taylor expanded in j around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6469.7%
Simplified69.7%
if -1.00000000000000006e140 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -2.00000000000000003e100Initial program 66.3%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified66.3%
Taylor expanded in y around inf
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6499.7%
Simplified99.7%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64100.0%
Applied egg-rr100.0%
if -2.00000000000000003e100 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.00000000000000005e149Initial program 84.8%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified86.5%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6473.8%
Simplified73.8%
Taylor expanded in j around 0
+-commutativeN/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6466.9%
Simplified66.9%
if 1.00000000000000005e149 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 76.3%
Taylor expanded in b around inf
*-lowering-*.f6471.4%
Simplified71.4%
Final simplification68.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
(let* ((t_1 (* x (+ (* i -4.0) (* y (* z (* 18.0 t)))))))
(if (<= x -9.2e+167)
t_1
(if (<= x 1.22e+151)
(+
(* t (+ (* (* (* x 18.0) y) z) (* a -4.0)))
(+ (* -27.0 (* j k)) (+ (* b c) (* 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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -9.2e+167) {
tmp = t_1;
} else if (x <= 1.22e+151) {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else {
tmp = t_1;
}
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 = x * ((i * (-4.0d0)) + (y * (z * (18.0d0 * t))))
if (x <= (-9.2d+167)) then
tmp = t_1
else if (x <= 1.22d+151) then
tmp = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + (((-27.0d0) * (j * k)) + ((b * c) + (x * (i * (-4.0d0)))))
else
tmp = t_1
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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -9.2e+167) {
tmp = t_1;
} else if (x <= 1.22e+151) {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = x * ((i * -4.0) + (y * (z * (18.0 * t)))) tmp = 0 if x <= -9.2e+167: tmp = t_1 elif x <= 1.22e+151: tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (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(x * Float64(Float64(i * -4.0) + Float64(y * Float64(z * Float64(18.0 * t))))) tmp = 0.0 if (x <= -9.2e+167) tmp = t_1; elseif (x <= 1.22e+151) tmp = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + Float64(Float64(-27.0 * Float64(j * k)) + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))))); else tmp = t_1; 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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
tmp = 0.0;
if (x <= -9.2e+167)
tmp = t_1;
elseif (x <= 1.22e+151)
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
else
tmp = t_1;
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[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -9.2e+167], t$95$1, If[LessEqual[x, 1.22e+151], N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $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 := x \cdot \left(i \cdot -4 + y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\right)\\
\mathbf{if}\;x \leq -9.2 \cdot 10^{+167}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.22 \cdot 10^{+151}:\\
\;\;\;\;t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + \left(-27 \cdot \left(j \cdot k\right) + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -9.19999999999999952e167 or 1.22000000000000005e151 < x Initial program 59.5%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified61.2%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6479.7%
Simplified79.7%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6484.9%
Applied egg-rr84.9%
if -9.19999999999999952e167 < x < 1.22000000000000005e151Initial program 87.9%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified90.4%
Final simplification89.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 (- (* b c) (* (* j 27.0) k))) (t_2 (* -4.0 (+ (* t a) (* x i)))))
(if (<= (* b c) -1.25e+138)
t_1
(if (<= (* b c) -1.45e-41)
t_2
(if (<= (* b c) 8.5e-140)
(+ (* t (* a -4.0)) (* j (* k -27.0)))
(if (<= (* b c) 8.5e+123) t_2 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 = (b * c) - ((j * 27.0) * k);
double t_2 = -4.0 * ((t * a) + (x * i));
double tmp;
if ((b * c) <= -1.25e+138) {
tmp = t_1;
} else if ((b * c) <= -1.45e-41) {
tmp = t_2;
} else if ((b * c) <= 8.5e-140) {
tmp = (t * (a * -4.0)) + (j * (k * -27.0));
} else if ((b * c) <= 8.5e+123) {
tmp = t_2;
} else {
tmp = t_1;
}
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) :: t_2
real(8) :: tmp
t_1 = (b * c) - ((j * 27.0d0) * k)
t_2 = (-4.0d0) * ((t * a) + (x * i))
if ((b * c) <= (-1.25d+138)) then
tmp = t_1
else if ((b * c) <= (-1.45d-41)) then
tmp = t_2
else if ((b * c) <= 8.5d-140) then
tmp = (t * (a * (-4.0d0))) + (j * (k * (-27.0d0)))
else if ((b * c) <= 8.5d+123) then
tmp = t_2
else
tmp = t_1
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 = (b * c) - ((j * 27.0) * k);
double t_2 = -4.0 * ((t * a) + (x * i));
double tmp;
if ((b * c) <= -1.25e+138) {
tmp = t_1;
} else if ((b * c) <= -1.45e-41) {
tmp = t_2;
} else if ((b * c) <= 8.5e-140) {
tmp = (t * (a * -4.0)) + (j * (k * -27.0));
} else if ((b * c) <= 8.5e+123) {
tmp = t_2;
} 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = (b * c) - ((j * 27.0) * k) t_2 = -4.0 * ((t * a) + (x * i)) tmp = 0 if (b * c) <= -1.25e+138: tmp = t_1 elif (b * c) <= -1.45e-41: tmp = t_2 elif (b * c) <= 8.5e-140: tmp = (t * (a * -4.0)) + (j * (k * -27.0)) elif (b * c) <= 8.5e+123: tmp = t_2 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(Float64(b * c) - Float64(Float64(j * 27.0) * k)) t_2 = Float64(-4.0 * Float64(Float64(t * a) + Float64(x * i))) tmp = 0.0 if (Float64(b * c) <= -1.25e+138) tmp = t_1; elseif (Float64(b * c) <= -1.45e-41) tmp = t_2; elseif (Float64(b * c) <= 8.5e-140) tmp = Float64(Float64(t * Float64(a * -4.0)) + Float64(j * Float64(k * -27.0))); elseif (Float64(b * c) <= 8.5e+123) tmp = t_2; else tmp = t_1; 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 = (b * c) - ((j * 27.0) * k);
t_2 = -4.0 * ((t * a) + (x * i));
tmp = 0.0;
if ((b * c) <= -1.25e+138)
tmp = t_1;
elseif ((b * c) <= -1.45e-41)
tmp = t_2;
elseif ((b * c) <= 8.5e-140)
tmp = (t * (a * -4.0)) + (j * (k * -27.0));
elseif ((b * c) <= 8.5e+123)
tmp = t_2;
else
tmp = t_1;
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[(b * c), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(-4.0 * N[(N[(t * a), $MachinePrecision] + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -1.25e+138], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], -1.45e-41], t$95$2, If[LessEqual[N[(b * c), $MachinePrecision], 8.5e-140], N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] + N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 8.5e+123], t$95$2, 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 := b \cdot c - \left(j \cdot 27\right) \cdot k\\
t_2 := -4 \cdot \left(t \cdot a + x \cdot i\right)\\
\mathbf{if}\;b \cdot c \leq -1.25 \cdot 10^{+138}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \cdot c \leq -1.45 \cdot 10^{-41}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \cdot c \leq 8.5 \cdot 10^{-140}:\\
\;\;\;\;t \cdot \left(a \cdot -4\right) + j \cdot \left(k \cdot -27\right)\\
\mathbf{elif}\;b \cdot c \leq 8.5 \cdot 10^{+123}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 b c) < -1.25000000000000004e138 or 8.5e123 < (*.f64 b c) Initial program 78.2%
Taylor expanded in b around inf
*-lowering-*.f6475.2%
Simplified75.2%
if -1.25000000000000004e138 < (*.f64 b c) < -1.44999999999999989e-41 or 8.49999999999999997e-140 < (*.f64 b c) < 8.5e123Initial program 80.2%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified84.4%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6473.6%
Simplified73.6%
Taylor expanded in j around 0
+-commutativeN/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6457.6%
Simplified57.6%
Taylor expanded in b around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6452.0%
Simplified52.0%
if -1.44999999999999989e-41 < (*.f64 b c) < 8.49999999999999997e-140Initial program 86.8%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified86.8%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6475.1%
Simplified75.1%
Taylor expanded in j around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6459.0%
Simplified59.0%
Final simplification61.8%
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 (* t (* a -4.0)))
(t_2 (* x (+ (* i -4.0) (* y (* z (* 18.0 t)))))))
(if (<= x -2.8e+56)
t_2
(if (<= x -7.2e-99)
(+ (* b c) t_1)
(if (<= x 4.1e-156)
(+ t_1 (* j (* k -27.0)))
(if (<= x 6.9e+100) (- (* b c) (* 27.0 (* j k))) t_2))))))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 = t * (a * -4.0);
double t_2 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -2.8e+56) {
tmp = t_2;
} else if (x <= -7.2e-99) {
tmp = (b * c) + t_1;
} else if (x <= 4.1e-156) {
tmp = t_1 + (j * (k * -27.0));
} else if (x <= 6.9e+100) {
tmp = (b * c) - (27.0 * (j * k));
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = t * (a * (-4.0d0))
t_2 = x * ((i * (-4.0d0)) + (y * (z * (18.0d0 * t))))
if (x <= (-2.8d+56)) then
tmp = t_2
else if (x <= (-7.2d-99)) then
tmp = (b * c) + t_1
else if (x <= 4.1d-156) then
tmp = t_1 + (j * (k * (-27.0d0)))
else if (x <= 6.9d+100) then
tmp = (b * c) - (27.0d0 * (j * k))
else
tmp = t_2
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 = t * (a * -4.0);
double t_2 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -2.8e+56) {
tmp = t_2;
} else if (x <= -7.2e-99) {
tmp = (b * c) + t_1;
} else if (x <= 4.1e-156) {
tmp = t_1 + (j * (k * -27.0));
} else if (x <= 6.9e+100) {
tmp = (b * c) - (27.0 * (j * k));
} else {
tmp = t_2;
}
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 = t * (a * -4.0) t_2 = x * ((i * -4.0) + (y * (z * (18.0 * t)))) tmp = 0 if x <= -2.8e+56: tmp = t_2 elif x <= -7.2e-99: tmp = (b * c) + t_1 elif x <= 4.1e-156: tmp = t_1 + (j * (k * -27.0)) elif x <= 6.9e+100: tmp = (b * c) - (27.0 * (j * k)) else: tmp = t_2 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(t * Float64(a * -4.0)) t_2 = Float64(x * Float64(Float64(i * -4.0) + Float64(y * Float64(z * Float64(18.0 * t))))) tmp = 0.0 if (x <= -2.8e+56) tmp = t_2; elseif (x <= -7.2e-99) tmp = Float64(Float64(b * c) + t_1); elseif (x <= 4.1e-156) tmp = Float64(t_1 + Float64(j * Float64(k * -27.0))); elseif (x <= 6.9e+100) tmp = Float64(Float64(b * c) - Float64(27.0 * Float64(j * k))); else tmp = t_2; 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 = t * (a * -4.0);
t_2 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
tmp = 0.0;
if (x <= -2.8e+56)
tmp = t_2;
elseif (x <= -7.2e-99)
tmp = (b * c) + t_1;
elseif (x <= 4.1e-156)
tmp = t_1 + (j * (k * -27.0));
elseif (x <= 6.9e+100)
tmp = (b * c) - (27.0 * (j * k));
else
tmp = t_2;
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[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.8e+56], t$95$2, If[LessEqual[x, -7.2e-99], N[(N[(b * c), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[x, 4.1e-156], N[(t$95$1 + N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 6.9e+100], N[(N[(b * c), $MachinePrecision] - N[(27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\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 := t \cdot \left(a \cdot -4\right)\\
t_2 := x \cdot \left(i \cdot -4 + y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\right)\\
\mathbf{if}\;x \leq -2.8 \cdot 10^{+56}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -7.2 \cdot 10^{-99}:\\
\;\;\;\;b \cdot c + t\_1\\
\mathbf{elif}\;x \leq 4.1 \cdot 10^{-156}:\\
\;\;\;\;t\_1 + j \cdot \left(k \cdot -27\right)\\
\mathbf{elif}\;x \leq 6.9 \cdot 10^{+100}:\\
\;\;\;\;b \cdot c - 27 \cdot \left(j \cdot k\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -2.80000000000000008e56 or 6.9000000000000001e100 < x Initial program 65.5%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified70.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.2%
Simplified72.2%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6475.6%
Applied egg-rr75.6%
if -2.80000000000000008e56 < x < -7.2000000000000001e-99Initial program 94.1%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified97.1%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.6%
Simplified82.6%
Taylor expanded in b around inf
*-lowering-*.f6469.3%
Simplified69.3%
if -7.2000000000000001e-99 < x < 4.1000000000000002e-156Initial program 92.9%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified92.8%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6480.5%
Simplified80.5%
Taylor expanded in j around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6464.0%
Simplified64.0%
if 4.1000000000000002e-156 < x < 6.9000000000000001e100Initial program 81.6%
Taylor expanded in b around inf
*-lowering-*.f6458.2%
Simplified58.2%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6458.3%
Applied egg-rr58.3%
Final simplification67.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
(let* ((t_1 (* -27.0 (* j k))))
(if (<= t -6e+60)
(-
(* t (+ (* a -4.0) (* x (* 18.0 (* y z)))))
(+ (* (* x 4.0) i) (* j (* 27.0 k))))
(if (<= t 4.4e-116)
(+ (+ t_1 (+ (* b c) (* x (* i -4.0)))) (* t (* a -4.0)))
(+ (* t (+ (* (* (* x 18.0) y) z) (* a -4.0))) (+ (* b c) 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 = -27.0 * (j * k);
double tmp;
if (t <= -6e+60) {
tmp = (t * ((a * -4.0) + (x * (18.0 * (y * z))))) - (((x * 4.0) * i) + (j * (27.0 * k)));
} else if (t <= 4.4e-116) {
tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
} else {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + t_1);
}
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 <= (-6d+60)) then
tmp = (t * ((a * (-4.0d0)) + (x * (18.0d0 * (y * z))))) - (((x * 4.0d0) * i) + (j * (27.0d0 * k)))
else if (t <= 4.4d-116) then
tmp = (t_1 + ((b * c) + (x * (i * (-4.0d0))))) + (t * (a * (-4.0d0)))
else
tmp = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + ((b * c) + t_1)
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 <= -6e+60) {
tmp = (t * ((a * -4.0) + (x * (18.0 * (y * z))))) - (((x * 4.0) * i) + (j * (27.0 * k)));
} else if (t <= 4.4e-116) {
tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
} else {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = -27.0 * (j * k) tmp = 0 if t <= -6e+60: tmp = (t * ((a * -4.0) + (x * (18.0 * (y * z))))) - (((x * 4.0) * i) + (j * (27.0 * k))) elif t <= 4.4e-116: tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0)) else: tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + 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(-27.0 * Float64(j * k)) tmp = 0.0 if (t <= -6e+60) tmp = Float64(Float64(t * Float64(Float64(a * -4.0) + Float64(x * Float64(18.0 * Float64(y * z))))) - Float64(Float64(Float64(x * 4.0) * i) + Float64(j * Float64(27.0 * k)))); elseif (t <= 4.4e-116) tmp = Float64(Float64(t_1 + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0)))) + Float64(t * Float64(a * -4.0))); else tmp = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + Float64(Float64(b * c) + t_1)); 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 <= -6e+60)
tmp = (t * ((a * -4.0) + (x * (18.0 * (y * z))))) - (((x * 4.0) * i) + (j * (27.0 * k)));
elseif (t <= 4.4e-116)
tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
else
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + t_1);
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[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6e+60], N[(N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision] + N[(j * N[(27.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.4e-116], N[(N[(t$95$1 + N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + t$95$1), $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 := -27 \cdot \left(j \cdot k\right)\\
\mathbf{if}\;t \leq -6 \cdot 10^{+60}:\\
\;\;\;\;t \cdot \left(a \cdot -4 + x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right) - \left(\left(x \cdot 4\right) \cdot i + j \cdot \left(27 \cdot k\right)\right)\\
\mathbf{elif}\;t \leq 4.4 \cdot 10^{-116}:\\
\;\;\;\;\left(t\_1 + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right) + t \cdot \left(a \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + \left(b \cdot c + t\_1\right)\\
\end{array}
\end{array}
if t < -5.9999999999999997e60Initial program 77.7%
Taylor expanded in b 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
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Simplified83.7%
if -5.9999999999999997e60 < t < 4.4000000000000002e-116Initial program 80.9%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified80.9%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.6%
Simplified85.6%
if 4.4000000000000002e-116 < t Initial program 84.4%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified87.8%
Taylor expanded in b around inf
*-lowering-*.f6488.4%
Simplified88.4%
Final simplification86.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)))
(t_2 (+ (* t (+ (* (* (* x 18.0) y) z) (* a -4.0))) (+ (* b c) t_1))))
(if (<= t -4400.0)
t_2
(if (<= t 6.5e-115)
(+ (+ t_1 (+ (* b c) (* x (* i -4.0)))) (* t (* a -4.0)))
t_2))))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 t_2 = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + t_1);
double tmp;
if (t <= -4400.0) {
tmp = t_2;
} else if (t <= 6.5e-115) {
tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
} else {
tmp = t_2;
}
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) :: t_2
real(8) :: tmp
t_1 = (-27.0d0) * (j * k)
t_2 = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + ((b * c) + t_1)
if (t <= (-4400.0d0)) then
tmp = t_2
else if (t <= 6.5d-115) then
tmp = (t_1 + ((b * c) + (x * (i * (-4.0d0))))) + (t * (a * (-4.0d0)))
else
tmp = t_2
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 t_2 = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + t_1);
double tmp;
if (t <= -4400.0) {
tmp = t_2;
} else if (t <= 6.5e-115) {
tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
} else {
tmp = t_2;
}
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) t_2 = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + t_1) tmp = 0 if t <= -4400.0: tmp = t_2 elif t <= 6.5e-115: tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0)) else: tmp = t_2 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(-27.0 * Float64(j * k)) t_2 = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + Float64(Float64(b * c) + t_1)) tmp = 0.0 if (t <= -4400.0) tmp = t_2; elseif (t <= 6.5e-115) tmp = Float64(Float64(t_1 + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0)))) + Float64(t * Float64(a * -4.0))); else tmp = t_2; 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);
t_2 = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + ((b * c) + t_1);
tmp = 0.0;
if (t <= -4400.0)
tmp = t_2;
elseif (t <= 6.5e-115)
tmp = (t_1 + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
else
tmp = t_2;
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[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4400.0], t$95$2, If[LessEqual[t, 6.5e-115], N[(N[(t$95$1 + N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\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 := -27 \cdot \left(j \cdot k\right)\\
t_2 := t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + \left(b \cdot c + t\_1\right)\\
\mathbf{if}\;t \leq -4400:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq 6.5 \cdot 10^{-115}:\\
\;\;\;\;\left(t\_1 + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right) + t \cdot \left(a \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -4400 or 6.50000000000000033e-115 < t Initial program 82.6%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified86.4%
Taylor expanded in b around inf
*-lowering-*.f6486.2%
Simplified86.2%
if -4400 < t < 6.50000000000000033e-115Initial program 79.8%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified79.8%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.9%
Simplified85.9%
Final simplification86.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
(-
(- (* z (* 18.0 (* y (* x t)))) (* (* x 4.0) i))
(* (* j 27.0) k))))
(if (<= z -3.5e-63)
t_1
(if (<= z 1.75e+186)
(+ (+ (* -27.0 (* j k)) (+ (* b c) (* x (* i -4.0)))) (* t (* a -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 = ((z * (18.0 * (y * (x * t)))) - ((x * 4.0) * i)) - ((j * 27.0) * k);
double tmp;
if (z <= -3.5e-63) {
tmp = t_1;
} else if (z <= 1.75e+186) {
tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
} else {
tmp = t_1;
}
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 = ((z * (18.0d0 * (y * (x * t)))) - ((x * 4.0d0) * i)) - ((j * 27.0d0) * k)
if (z <= (-3.5d-63)) then
tmp = t_1
else if (z <= 1.75d+186) then
tmp = (((-27.0d0) * (j * k)) + ((b * c) + (x * (i * (-4.0d0))))) + (t * (a * (-4.0d0)))
else
tmp = t_1
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 = ((z * (18.0 * (y * (x * t)))) - ((x * 4.0) * i)) - ((j * 27.0) * k);
double tmp;
if (z <= -3.5e-63) {
tmp = t_1;
} else if (z <= 1.75e+186) {
tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = ((z * (18.0 * (y * (x * t)))) - ((x * 4.0) * i)) - ((j * 27.0) * k) tmp = 0 if z <= -3.5e-63: tmp = t_1 elif z <= 1.75e+186: tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -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(Float64(Float64(z * Float64(18.0 * Float64(y * Float64(x * t)))) - Float64(Float64(x * 4.0) * i)) - Float64(Float64(j * 27.0) * k)) tmp = 0.0 if (z <= -3.5e-63) tmp = t_1; elseif (z <= 1.75e+186) tmp = Float64(Float64(Float64(-27.0 * Float64(j * k)) + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0)))) + Float64(t * Float64(a * -4.0))); else tmp = t_1; 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 = ((z * (18.0 * (y * (x * t)))) - ((x * 4.0) * i)) - ((j * 27.0) * k);
tmp = 0.0;
if (z <= -3.5e-63)
tmp = t_1;
elseif (z <= 1.75e+186)
tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
else
tmp = t_1;
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[(N[(z * N[(18.0 * N[(y * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.5e-63], t$95$1, If[LessEqual[z, 1.75e+186], N[(N[(N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t * N[(a * -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 := \left(z \cdot \left(18 \cdot \left(y \cdot \left(x \cdot t\right)\right)\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k\\
\mathbf{if}\;z \leq -3.5 \cdot 10^{-63}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.75 \cdot 10^{+186}:\\
\;\;\;\;\left(-27 \cdot \left(j \cdot k\right) + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right) + t \cdot \left(a \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.50000000000000003e-63 or 1.74999999999999993e186 < z Initial program 72.4%
Taylor expanded in x around inf
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6465.3%
Simplified65.3%
if -3.50000000000000003e-63 < z < 1.74999999999999993e186Initial program 87.7%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified88.3%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6484.7%
Simplified84.7%
Final simplification76.8%
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 (* x (+ (* i -4.0) (* y (* z (* 18.0 t)))))))
(if (<= x -2.5e+165)
t_1
(if (<= x 4.4e+146)
(+ (+ (* -27.0 (* j k)) (+ (* b c) (* x (* i -4.0)))) (* t (* a -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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -2.5e+165) {
tmp = t_1;
} else if (x <= 4.4e+146) {
tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
} else {
tmp = t_1;
}
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 = x * ((i * (-4.0d0)) + (y * (z * (18.0d0 * t))))
if (x <= (-2.5d+165)) then
tmp = t_1
else if (x <= 4.4d+146) then
tmp = (((-27.0d0) * (j * k)) + ((b * c) + (x * (i * (-4.0d0))))) + (t * (a * (-4.0d0)))
else
tmp = t_1
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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -2.5e+165) {
tmp = t_1;
} else if (x <= 4.4e+146) {
tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = x * ((i * -4.0) + (y * (z * (18.0 * t)))) tmp = 0 if x <= -2.5e+165: tmp = t_1 elif x <= 4.4e+146: tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -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(x * Float64(Float64(i * -4.0) + Float64(y * Float64(z * Float64(18.0 * t))))) tmp = 0.0 if (x <= -2.5e+165) tmp = t_1; elseif (x <= 4.4e+146) tmp = Float64(Float64(Float64(-27.0 * Float64(j * k)) + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0)))) + Float64(t * Float64(a * -4.0))); else tmp = t_1; 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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
tmp = 0.0;
if (x <= -2.5e+165)
tmp = t_1;
elseif (x <= 4.4e+146)
tmp = ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) + (t * (a * -4.0));
else
tmp = t_1;
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[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.5e+165], t$95$1, If[LessEqual[x, 4.4e+146], N[(N[(N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t * N[(a * -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 := x \cdot \left(i \cdot -4 + y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\right)\\
\mathbf{if}\;x \leq -2.5 \cdot 10^{+165}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.4 \cdot 10^{+146}:\\
\;\;\;\;\left(-27 \cdot \left(j \cdot k\right) + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right) + t \cdot \left(a \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.49999999999999985e165 or 4.3999999999999996e146 < x Initial program 58.5%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified61.9%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6480.1%
Simplified80.1%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.1%
Applied egg-rr85.1%
if -2.49999999999999985e165 < x < 4.3999999999999996e146Initial program 88.3%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified90.4%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6478.8%
Simplified78.8%
Final simplification80.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
(if (<= (* b c) -4.1e+130)
(* b c)
(if (<= (* b c) -3.6e-42)
(* -4.0 (* x i))
(if (<= (* b c) 4.4e+155) (* k (* j -27.0)) (* b c)))))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 ((b * c) <= -4.1e+130) {
tmp = b * c;
} else if ((b * c) <= -3.6e-42) {
tmp = -4.0 * (x * i);
} else if ((b * c) <= 4.4e+155) {
tmp = k * (j * -27.0);
} else {
tmp = b * c;
}
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 ((b * c) <= (-4.1d+130)) then
tmp = b * c
else if ((b * c) <= (-3.6d-42)) then
tmp = (-4.0d0) * (x * i)
else if ((b * c) <= 4.4d+155) then
tmp = k * (j * (-27.0d0))
else
tmp = b * c
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 ((b * c) <= -4.1e+130) {
tmp = b * c;
} else if ((b * c) <= -3.6e-42) {
tmp = -4.0 * (x * i);
} else if ((b * c) <= 4.4e+155) {
tmp = k * (j * -27.0);
} else {
tmp = b * c;
}
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 (b * c) <= -4.1e+130: tmp = b * c elif (b * c) <= -3.6e-42: tmp = -4.0 * (x * i) elif (b * c) <= 4.4e+155: tmp = k * (j * -27.0) else: tmp = b * c 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(b * c) <= -4.1e+130) tmp = Float64(b * c); elseif (Float64(b * c) <= -3.6e-42) tmp = Float64(-4.0 * Float64(x * i)); elseif (Float64(b * c) <= 4.4e+155) tmp = Float64(k * Float64(j * -27.0)); else tmp = Float64(b * c); 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 ((b * c) <= -4.1e+130)
tmp = b * c;
elseif ((b * c) <= -3.6e-42)
tmp = -4.0 * (x * i);
elseif ((b * c) <= 4.4e+155)
tmp = k * (j * -27.0);
else
tmp = b * c;
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[(b * c), $MachinePrecision], -4.1e+130], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -3.6e-42], N[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 4.4e+155], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $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}\;b \cdot c \leq -4.1 \cdot 10^{+130}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;b \cdot c \leq -3.6 \cdot 10^{-42}:\\
\;\;\;\;-4 \cdot \left(x \cdot i\right)\\
\mathbf{elif}\;b \cdot c \leq 4.4 \cdot 10^{+155}:\\
\;\;\;\;k \cdot \left(j \cdot -27\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot c\\
\end{array}
\end{array}
if (*.f64 b c) < -4.09999999999999978e130 or 4.4000000000000005e155 < (*.f64 b c) Initial program 78.2%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified80.6%
Taylor expanded in b around inf
*-lowering-*.f6464.7%
Simplified64.7%
if -4.09999999999999978e130 < (*.f64 b c) < -3.6000000000000002e-42Initial program 79.5%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified82.2%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6434.3%
Simplified34.3%
if -3.6000000000000002e-42 < (*.f64 b c) < 4.4000000000000005e155Initial program 84.0%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified86.2%
Taylor expanded in j around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6431.1%
Simplified31.1%
Final simplification42.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 (<= (* b c) -4.1e+130)
(* b c)
(if (<= (* b c) -2.2e-41)
(* -4.0 (* x i))
(if (<= (* b c) 1.15e+156) (* j (* k -27.0)) (* b c)))))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 ((b * c) <= -4.1e+130) {
tmp = b * c;
} else if ((b * c) <= -2.2e-41) {
tmp = -4.0 * (x * i);
} else if ((b * c) <= 1.15e+156) {
tmp = j * (k * -27.0);
} else {
tmp = b * c;
}
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 ((b * c) <= (-4.1d+130)) then
tmp = b * c
else if ((b * c) <= (-2.2d-41)) then
tmp = (-4.0d0) * (x * i)
else if ((b * c) <= 1.15d+156) then
tmp = j * (k * (-27.0d0))
else
tmp = b * c
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 ((b * c) <= -4.1e+130) {
tmp = b * c;
} else if ((b * c) <= -2.2e-41) {
tmp = -4.0 * (x * i);
} else if ((b * c) <= 1.15e+156) {
tmp = j * (k * -27.0);
} else {
tmp = b * c;
}
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 (b * c) <= -4.1e+130: tmp = b * c elif (b * c) <= -2.2e-41: tmp = -4.0 * (x * i) elif (b * c) <= 1.15e+156: tmp = j * (k * -27.0) else: tmp = b * c 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(b * c) <= -4.1e+130) tmp = Float64(b * c); elseif (Float64(b * c) <= -2.2e-41) tmp = Float64(-4.0 * Float64(x * i)); elseif (Float64(b * c) <= 1.15e+156) tmp = Float64(j * Float64(k * -27.0)); else tmp = Float64(b * c); 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 ((b * c) <= -4.1e+130)
tmp = b * c;
elseif ((b * c) <= -2.2e-41)
tmp = -4.0 * (x * i);
elseif ((b * c) <= 1.15e+156)
tmp = j * (k * -27.0);
else
tmp = b * c;
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[(b * c), $MachinePrecision], -4.1e+130], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], -2.2e-41], N[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.15e+156], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], N[(b * c), $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}\;b \cdot c \leq -4.1 \cdot 10^{+130}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;b \cdot c \leq -2.2 \cdot 10^{-41}:\\
\;\;\;\;-4 \cdot \left(x \cdot i\right)\\
\mathbf{elif}\;b \cdot c \leq 1.15 \cdot 10^{+156}:\\
\;\;\;\;j \cdot \left(k \cdot -27\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot c\\
\end{array}
\end{array}
if (*.f64 b c) < -4.09999999999999978e130 or 1.1499999999999999e156 < (*.f64 b c) Initial program 78.2%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified80.6%
Taylor expanded in b around inf
*-lowering-*.f6464.7%
Simplified64.7%
if -4.09999999999999978e130 < (*.f64 b c) < -2.2e-41Initial program 79.5%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified82.2%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6434.3%
Simplified34.3%
if -2.2e-41 < (*.f64 b c) < 1.1499999999999999e156Initial program 84.0%
Taylor expanded in t around inf
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6484.0%
Simplified84.0%
Taylor expanded in j around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6431.1%
Simplified31.1%
Final simplification42.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
(let* ((t_1 (* t (+ (* a -4.0) (* x (* 18.0 (* y z)))))))
(if (<= t -7.2e+107)
t_1
(if (<= t 8.5e+75)
(- (- (* b c) (* (* x 4.0) i)) (* (* j 27.0) k))
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 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
double tmp;
if (t <= -7.2e+107) {
tmp = t_1;
} else if (t <= 8.5e+75) {
tmp = ((b * c) - ((x * 4.0) * i)) - ((j * 27.0) * k);
} else {
tmp = t_1;
}
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 = t * ((a * (-4.0d0)) + (x * (18.0d0 * (y * z))))
if (t <= (-7.2d+107)) then
tmp = t_1
else if (t <= 8.5d+75) then
tmp = ((b * c) - ((x * 4.0d0) * i)) - ((j * 27.0d0) * k)
else
tmp = t_1
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 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
double tmp;
if (t <= -7.2e+107) {
tmp = t_1;
} else if (t <= 8.5e+75) {
tmp = ((b * c) - ((x * 4.0) * i)) - ((j * 27.0) * k);
} 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = t * ((a * -4.0) + (x * (18.0 * (y * z)))) tmp = 0 if t <= -7.2e+107: tmp = t_1 elif t <= 8.5e+75: tmp = ((b * c) - ((x * 4.0) * i)) - ((j * 27.0) * k) 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(t * Float64(Float64(a * -4.0) + Float64(x * Float64(18.0 * Float64(y * z))))) tmp = 0.0 if (t <= -7.2e+107) tmp = t_1; elseif (t <= 8.5e+75) tmp = Float64(Float64(Float64(b * c) - Float64(Float64(x * 4.0) * i)) - Float64(Float64(j * 27.0) * k)); else tmp = t_1; 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 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
tmp = 0.0;
if (t <= -7.2e+107)
tmp = t_1;
elseif (t <= 8.5e+75)
tmp = ((b * c) - ((x * 4.0) * i)) - ((j * 27.0) * k);
else
tmp = t_1;
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[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.2e+107], t$95$1, If[LessEqual[t, 8.5e+75], N[(N[(N[(b * c), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $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 := t \cdot \left(a \cdot -4 + x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\
\mathbf{if}\;t \leq -7.2 \cdot 10^{+107}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{+75}:\\
\;\;\;\;\left(b \cdot c - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -7.1999999999999995e107 or 8.4999999999999993e75 < t Initial program 81.8%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified86.6%
Taylor expanded in t around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.9%
Simplified72.9%
if -7.1999999999999995e107 < t < 8.4999999999999993e75Initial program 81.2%
Taylor expanded in t around 0
*-lowering-*.f6477.0%
Simplified77.0%
Final simplification75.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
(let* ((t_1 (* x (+ (* i -4.0) (* y (* z (* 18.0 t)))))))
(if (<= x -5.3e+147)
t_1
(if (<= x 1.25e+102)
(+ (* t (* a -4.0)) (+ (* b c) (* -27.0 (* j k))))
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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -5.3e+147) {
tmp = t_1;
} else if (x <= 1.25e+102) {
tmp = (t * (a * -4.0)) + ((b * c) + (-27.0 * (j * k)));
} else {
tmp = t_1;
}
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 = x * ((i * (-4.0d0)) + (y * (z * (18.0d0 * t))))
if (x <= (-5.3d+147)) then
tmp = t_1
else if (x <= 1.25d+102) then
tmp = (t * (a * (-4.0d0))) + ((b * c) + ((-27.0d0) * (j * k)))
else
tmp = t_1
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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
double tmp;
if (x <= -5.3e+147) {
tmp = t_1;
} else if (x <= 1.25e+102) {
tmp = (t * (a * -4.0)) + ((b * c) + (-27.0 * (j * k)));
} 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = x * ((i * -4.0) + (y * (z * (18.0 * t)))) tmp = 0 if x <= -5.3e+147: tmp = t_1 elif x <= 1.25e+102: tmp = (t * (a * -4.0)) + ((b * c) + (-27.0 * (j * k))) 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(x * Float64(Float64(i * -4.0) + Float64(y * Float64(z * Float64(18.0 * t))))) tmp = 0.0 if (x <= -5.3e+147) tmp = t_1; elseif (x <= 1.25e+102) tmp = Float64(Float64(t * Float64(a * -4.0)) + Float64(Float64(b * c) + Float64(-27.0 * Float64(j * k)))); else tmp = t_1; 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 = x * ((i * -4.0) + (y * (z * (18.0 * t))));
tmp = 0.0;
if (x <= -5.3e+147)
tmp = t_1;
elseif (x <= 1.25e+102)
tmp = (t * (a * -4.0)) + ((b * c) + (-27.0 * (j * k)));
else
tmp = t_1;
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[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.3e+147], t$95$1, If[LessEqual[x, 1.25e+102], N[(N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision] + N[(N[(b * c), $MachinePrecision] + N[(-27.0 * N[(j * k), $MachinePrecision]), $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 := x \cdot \left(i \cdot -4 + y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\right)\\
\mathbf{if}\;x \leq -5.3 \cdot 10^{+147}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.25 \cdot 10^{+102}:\\
\;\;\;\;t \cdot \left(a \cdot -4\right) + \left(b \cdot c + -27 \cdot \left(j \cdot k\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -5.3000000000000002e147 or 1.25e102 < x Initial program 63.6%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified66.4%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6477.8%
Simplified77.8%
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.1%
Applied egg-rr82.1%
if -5.3000000000000002e147 < x < 1.25e102Initial program 88.2%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified90.4%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6478.0%
Simplified78.0%
Taylor expanded in b around inf
*-lowering-*.f6471.4%
Simplified71.4%
Final simplification74.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
(let* ((t_1 (* j (* k -27.0))))
(if (<= k -2e+28)
t_1
(if (<= k 7.5e+98)
(+ (* b c) (* x (* i -4.0)))
(if (<= k 2.4e+233) (* z (* 18.0 (* y (* x t)))) 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 = j * (k * -27.0);
double tmp;
if (k <= -2e+28) {
tmp = t_1;
} else if (k <= 7.5e+98) {
tmp = (b * c) + (x * (i * -4.0));
} else if (k <= 2.4e+233) {
tmp = z * (18.0 * (y * (x * t)));
} else {
tmp = t_1;
}
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 = j * (k * (-27.0d0))
if (k <= (-2d+28)) then
tmp = t_1
else if (k <= 7.5d+98) then
tmp = (b * c) + (x * (i * (-4.0d0)))
else if (k <= 2.4d+233) then
tmp = z * (18.0d0 * (y * (x * t)))
else
tmp = t_1
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 = j * (k * -27.0);
double tmp;
if (k <= -2e+28) {
tmp = t_1;
} else if (k <= 7.5e+98) {
tmp = (b * c) + (x * (i * -4.0));
} else if (k <= 2.4e+233) {
tmp = z * (18.0 * (y * (x * t)));
} 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = j * (k * -27.0) tmp = 0 if k <= -2e+28: tmp = t_1 elif k <= 7.5e+98: tmp = (b * c) + (x * (i * -4.0)) elif k <= 2.4e+233: tmp = z * (18.0 * (y * (x * t))) 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(j * Float64(k * -27.0)) tmp = 0.0 if (k <= -2e+28) tmp = t_1; elseif (k <= 7.5e+98) tmp = Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))); elseif (k <= 2.4e+233) tmp = Float64(z * Float64(18.0 * Float64(y * Float64(x * t)))); else tmp = t_1; 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 = j * (k * -27.0);
tmp = 0.0;
if (k <= -2e+28)
tmp = t_1;
elseif (k <= 7.5e+98)
tmp = (b * c) + (x * (i * -4.0));
elseif (k <= 2.4e+233)
tmp = z * (18.0 * (y * (x * t)));
else
tmp = t_1;
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[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -2e+28], t$95$1, If[LessEqual[k, 7.5e+98], N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.4e+233], N[(z * N[(18.0 * N[(y * N[(x * t), $MachinePrecision]), $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 := j \cdot \left(k \cdot -27\right)\\
\mathbf{if}\;k \leq -2 \cdot 10^{+28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 7.5 \cdot 10^{+98}:\\
\;\;\;\;b \cdot c + x \cdot \left(i \cdot -4\right)\\
\mathbf{elif}\;k \leq 2.4 \cdot 10^{+233}:\\
\;\;\;\;z \cdot \left(18 \cdot \left(y \cdot \left(x \cdot t\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -1.99999999999999992e28 or 2.40000000000000003e233 < k Initial program 78.9%
Taylor expanded in t around inf
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6473.9%
Simplified73.9%
Taylor expanded in j around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6450.5%
Simplified50.5%
if -1.99999999999999992e28 < k < 7.50000000000000036e98Initial program 82.6%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified83.9%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.9%
Simplified69.9%
Taylor expanded in j around 0
+-commutativeN/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6461.1%
Simplified61.1%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6446.2%
Simplified46.2%
if 7.50000000000000036e98 < k < 2.40000000000000003e233Initial program 82.1%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified89.2%
Taylor expanded in y around inf
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6440.2%
Simplified40.2%
Final simplification46.8%
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 (* t (+ (* a -4.0) (* x (* 18.0 (* y z)))))))
(if (<= t -2e+58)
t_1
(if (<= t 1.15e+74) (- (* b c) (* 27.0 (* j k))) 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 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
double tmp;
if (t <= -2e+58) {
tmp = t_1;
} else if (t <= 1.15e+74) {
tmp = (b * c) - (27.0 * (j * k));
} else {
tmp = t_1;
}
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 = t * ((a * (-4.0d0)) + (x * (18.0d0 * (y * z))))
if (t <= (-2d+58)) then
tmp = t_1
else if (t <= 1.15d+74) then
tmp = (b * c) - (27.0d0 * (j * k))
else
tmp = t_1
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 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
double tmp;
if (t <= -2e+58) {
tmp = t_1;
} else if (t <= 1.15e+74) {
tmp = (b * c) - (27.0 * (j * k));
} 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = t * ((a * -4.0) + (x * (18.0 * (y * z)))) tmp = 0 if t <= -2e+58: tmp = t_1 elif t <= 1.15e+74: tmp = (b * c) - (27.0 * (j * k)) 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(t * Float64(Float64(a * -4.0) + Float64(x * Float64(18.0 * Float64(y * z))))) tmp = 0.0 if (t <= -2e+58) tmp = t_1; elseif (t <= 1.15e+74) tmp = Float64(Float64(b * c) - Float64(27.0 * Float64(j * k))); else tmp = t_1; 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 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
tmp = 0.0;
if (t <= -2e+58)
tmp = t_1;
elseif (t <= 1.15e+74)
tmp = (b * c) - (27.0 * (j * k));
else
tmp = t_1;
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[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2e+58], t$95$1, If[LessEqual[t, 1.15e+74], N[(N[(b * c), $MachinePrecision] - N[(27.0 * N[(j * k), $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 := t \cdot \left(a \cdot -4 + x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\
\mathbf{if}\;t \leq -2 \cdot 10^{+58}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{+74}:\\
\;\;\;\;b \cdot c - 27 \cdot \left(j \cdot k\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.99999999999999989e58 or 1.1499999999999999e74 < t Initial program 80.1%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified85.5%
Taylor expanded in t around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.6%
Simplified72.6%
if -1.99999999999999989e58 < t < 1.1499999999999999e74Initial program 82.5%
Taylor expanded in b around inf
*-lowering-*.f6456.2%
Simplified56.2%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6456.2%
Applied egg-rr56.2%
Final simplification63.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
(let* ((t_1 (- (* b c) (* (* j 27.0) k))))
(if (<= (* b c) -9e+137)
t_1
(if (<= (* b c) 4e+123) (* -4.0 (+ (* t a) (* x i))) 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 = (b * c) - ((j * 27.0) * k);
double tmp;
if ((b * c) <= -9e+137) {
tmp = t_1;
} else if ((b * c) <= 4e+123) {
tmp = -4.0 * ((t * a) + (x * i));
} else {
tmp = t_1;
}
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 = (b * c) - ((j * 27.0d0) * k)
if ((b * c) <= (-9d+137)) then
tmp = t_1
else if ((b * c) <= 4d+123) then
tmp = (-4.0d0) * ((t * a) + (x * i))
else
tmp = t_1
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 = (b * c) - ((j * 27.0) * k);
double tmp;
if ((b * c) <= -9e+137) {
tmp = t_1;
} else if ((b * c) <= 4e+123) {
tmp = -4.0 * ((t * a) + (x * i));
} 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]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = (b * c) - ((j * 27.0) * k) tmp = 0 if (b * c) <= -9e+137: tmp = t_1 elif (b * c) <= 4e+123: tmp = -4.0 * ((t * a) + (x * i)) 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(Float64(b * c) - Float64(Float64(j * 27.0) * k)) tmp = 0.0 if (Float64(b * c) <= -9e+137) tmp = t_1; elseif (Float64(b * c) <= 4e+123) tmp = Float64(-4.0 * Float64(Float64(t * a) + Float64(x * i))); else tmp = t_1; 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 = (b * c) - ((j * 27.0) * k);
tmp = 0.0;
if ((b * c) <= -9e+137)
tmp = t_1;
elseif ((b * c) <= 4e+123)
tmp = -4.0 * ((t * a) + (x * i));
else
tmp = t_1;
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[(b * c), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(b * c), $MachinePrecision], -9e+137], t$95$1, If[LessEqual[N[(b * c), $MachinePrecision], 4e+123], N[(-4.0 * N[(N[(t * a), $MachinePrecision] + N[(x * i), $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 := b \cdot c - \left(j \cdot 27\right) \cdot k\\
\mathbf{if}\;b \cdot c \leq -9 \cdot 10^{+137}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \cdot c \leq 4 \cdot 10^{+123}:\\
\;\;\;\;-4 \cdot \left(t \cdot a + x \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 b c) < -9.0000000000000003e137 or 3.99999999999999991e123 < (*.f64 b c) Initial program 78.2%
Taylor expanded in b around inf
*-lowering-*.f6475.2%
Simplified75.2%
if -9.0000000000000003e137 < (*.f64 b c) < 3.99999999999999991e123Initial program 83.1%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified85.5%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.3%
Simplified74.3%
Taylor expanded in j around 0
+-commutativeN/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6450.6%
Simplified50.6%
Taylor expanded in b around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6446.9%
Simplified46.9%
Final simplification56.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 (if (<= (* b c) -2.1e+139) (* b c) (if (<= (* b c) 9.5e+126) (* -4.0 (+ (* t a) (* x i))) (* b c))))
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 ((b * c) <= -2.1e+139) {
tmp = b * c;
} else if ((b * c) <= 9.5e+126) {
tmp = -4.0 * ((t * a) + (x * i));
} else {
tmp = b * c;
}
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 ((b * c) <= (-2.1d+139)) then
tmp = b * c
else if ((b * c) <= 9.5d+126) then
tmp = (-4.0d0) * ((t * a) + (x * i))
else
tmp = b * c
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 ((b * c) <= -2.1e+139) {
tmp = b * c;
} else if ((b * c) <= 9.5e+126) {
tmp = -4.0 * ((t * a) + (x * i));
} else {
tmp = b * c;
}
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 (b * c) <= -2.1e+139: tmp = b * c elif (b * c) <= 9.5e+126: tmp = -4.0 * ((t * a) + (x * i)) else: tmp = b * c 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(b * c) <= -2.1e+139) tmp = Float64(b * c); elseif (Float64(b * c) <= 9.5e+126) tmp = Float64(-4.0 * Float64(Float64(t * a) + Float64(x * i))); else tmp = Float64(b * c); 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 ((b * c) <= -2.1e+139)
tmp = b * c;
elseif ((b * c) <= 9.5e+126)
tmp = -4.0 * ((t * a) + (x * i));
else
tmp = b * c;
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[(b * c), $MachinePrecision], -2.1e+139], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 9.5e+126], N[(-4.0 * N[(N[(t * a), $MachinePrecision] + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b * c), $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}\;b \cdot c \leq -2.1 \cdot 10^{+139}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;b \cdot c \leq 9.5 \cdot 10^{+126}:\\
\;\;\;\;-4 \cdot \left(t \cdot a + x \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot c\\
\end{array}
\end{array}
if (*.f64 b c) < -2.0999999999999999e139 or 9.49999999999999951e126 < (*.f64 b c) Initial program 78.2%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified80.5%
Taylor expanded in b around inf
*-lowering-*.f6462.8%
Simplified62.8%
if -2.0999999999999999e139 < (*.f64 b c) < 9.49999999999999951e126Initial program 83.1%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified85.5%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.3%
Simplified74.3%
Taylor expanded in j around 0
+-commutativeN/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6450.6%
Simplified50.6%
Taylor expanded in b around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6446.9%
Simplified46.9%
Final simplification52.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 (<= x -5.2e+57)
(* z (* 18.0 (* y (* x t))))
(if (<= x 1.25e-120)
(+ (* b c) (* t (* a -4.0)))
(+ (* b c) (* 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 tmp;
if (x <= -5.2e+57) {
tmp = z * (18.0 * (y * (x * t)));
} else if (x <= 1.25e-120) {
tmp = (b * c) + (t * (a * -4.0));
} else {
tmp = (b * c) + (x * (i * -4.0));
}
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 (x <= (-5.2d+57)) then
tmp = z * (18.0d0 * (y * (x * t)))
else if (x <= 1.25d-120) then
tmp = (b * c) + (t * (a * (-4.0d0)))
else
tmp = (b * c) + (x * (i * (-4.0d0)))
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 (x <= -5.2e+57) {
tmp = z * (18.0 * (y * (x * t)));
} else if (x <= 1.25e-120) {
tmp = (b * c) + (t * (a * -4.0));
} else {
tmp = (b * c) + (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]) def code(x, y, z, t, a, b, c, i, j, k): tmp = 0 if x <= -5.2e+57: tmp = z * (18.0 * (y * (x * t))) elif x <= 1.25e-120: tmp = (b * c) + (t * (a * -4.0)) else: tmp = (b * c) + (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) tmp = 0.0 if (x <= -5.2e+57) tmp = Float64(z * Float64(18.0 * Float64(y * Float64(x * t)))); elseif (x <= 1.25e-120) tmp = Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))); else tmp = Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))); 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 (x <= -5.2e+57)
tmp = z * (18.0 * (y * (x * t)));
elseif (x <= 1.25e-120)
tmp = (b * c) + (t * (a * -4.0));
else
tmp = (b * c) + (x * (i * -4.0));
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[x, -5.2e+57], N[(z * N[(18.0 * N[(y * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.25e-120], N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.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}\;x \leq -5.2 \cdot 10^{+57}:\\
\;\;\;\;z \cdot \left(18 \cdot \left(y \cdot \left(x \cdot t\right)\right)\right)\\
\mathbf{elif}\;x \leq 1.25 \cdot 10^{-120}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot c + x \cdot \left(i \cdot -4\right)\\
\end{array}
\end{array}
if x < -5.2e57Initial program 66.6%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified72.3%
Taylor expanded in y around inf
associate-*r*N/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6453.2%
Simplified53.2%
if -5.2e57 < x < 1.25000000000000002e-120Initial program 93.6%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified94.4%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.3%
Simplified82.3%
Taylor expanded in b around inf
*-lowering-*.f6454.1%
Simplified54.1%
if 1.25000000000000002e-120 < x Initial program 71.5%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified74.1%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.9%
Simplified69.9%
Taylor expanded in j around 0
+-commutativeN/A
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6453.7%
Simplified53.7%
Taylor expanded in t around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6452.5%
Simplified52.5%
Final simplification53.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 (<= (* b c) -3.95e+130) (* b c) (if (<= (* b c) 1.85e+97) (* -4.0 (* x i)) (* b c))))
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 ((b * c) <= -3.95e+130) {
tmp = b * c;
} else if ((b * c) <= 1.85e+97) {
tmp = -4.0 * (x * i);
} else {
tmp = b * c;
}
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 ((b * c) <= (-3.95d+130)) then
tmp = b * c
else if ((b * c) <= 1.85d+97) then
tmp = (-4.0d0) * (x * i)
else
tmp = b * c
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 ((b * c) <= -3.95e+130) {
tmp = b * c;
} else if ((b * c) <= 1.85e+97) {
tmp = -4.0 * (x * i);
} else {
tmp = b * c;
}
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 (b * c) <= -3.95e+130: tmp = b * c elif (b * c) <= 1.85e+97: tmp = -4.0 * (x * i) else: tmp = b * c 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(b * c) <= -3.95e+130) tmp = Float64(b * c); elseif (Float64(b * c) <= 1.85e+97) tmp = Float64(-4.0 * Float64(x * i)); else tmp = Float64(b * c); 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 ((b * c) <= -3.95e+130)
tmp = b * c;
elseif ((b * c) <= 1.85e+97)
tmp = -4.0 * (x * i);
else
tmp = b * c;
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[(b * c), $MachinePrecision], -3.95e+130], N[(b * c), $MachinePrecision], If[LessEqual[N[(b * c), $MachinePrecision], 1.85e+97], N[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision], N[(b * c), $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}\;b \cdot c \leq -3.95 \cdot 10^{+130}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;b \cdot c \leq 1.85 \cdot 10^{+97}:\\
\;\;\;\;-4 \cdot \left(x \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot c\\
\end{array}
\end{array}
if (*.f64 b c) < -3.9500000000000002e130 or 1.85e97 < (*.f64 b c) Initial program 78.1%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified81.3%
Taylor expanded in b around inf
*-lowering-*.f6458.2%
Simplified58.2%
if -3.9500000000000002e130 < (*.f64 b c) < 1.85e97Initial program 83.4%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified85.3%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6426.6%
Simplified26.6%
Final simplification38.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 (* b c))
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 b * c;
}
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 = b * c
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 b * c;
}
[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 b * c
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(b * c) 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 = b * c;
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[(b * c), $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])\\
\\
b \cdot c
\end{array}
Initial program 81.5%
associate--l+N/A
associate--l+N/A
+-lowering-+.f64N/A
distribute-rgt-out--N/A
*-lowering-*.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
metadata-evalN/A
Simplified83.8%
Taylor expanded in b around inf
*-lowering-*.f6424.8%
Simplified24.8%
(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 2024163
(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)))