
(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 26 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) (* t (* a 4.0))) (* b c))
(* (* x 4.0) i))
(* (* j 27.0) k))))
(if (<= t_1 INFINITY)
t_1
(* c (+ b (/ (* t (+ (* a -4.0) (* 18.0 (* z (* x y))))) 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 t_1 = (((((((x * 18.0) * y) * z) * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / c));
}
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) * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / 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): t_1 = (((((((x * 18.0) * y) * z) * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / 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) t_1 = Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * 18.0) * y) * z) * t) - Float64(t * Float64(a * 4.0))) + Float64(b * c)) - Float64(Float64(x * 4.0) * i)) - Float64(Float64(j * 27.0) * k)) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(c * Float64(b + Float64(Float64(t * Float64(Float64(a * -4.0) + Float64(18.0 * Float64(z * Float64(x * y))))) / 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)
t_1 = (((((((x * 18.0) * y) * z) * t) - (t * (a * 4.0))) + (b * c)) - ((x * 4.0) * i)) - ((j * 27.0) * k);
tmp = 0.0;
if (t_1 <= Inf)
tmp = t_1;
else
tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / 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_] := Block[{t$95$1 = N[(N[(N[(N[(N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] * 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] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(c * N[(b + N[(N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(18.0 * N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $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(\left(\left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z\right) \cdot t - t \cdot \left(a \cdot 4\right)\right) + b \cdot c\right) - \left(x \cdot 4\right) \cdot i\right) - \left(j \cdot 27\right) \cdot k\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(b + \frac{t \cdot \left(a \cdot -4 + 18 \cdot \left(z \cdot \left(x \cdot y\right)\right)\right)}{c}\right)\\
\end{array}
\end{array}
if (-.f64 (-.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)) (*.f64 (*.f64 j #s(literal 27 binary64)) k)) < +inf.0Initial program 95.4%
if +inf.0 < (-.f64 (-.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)) (*.f64 (*.f64 j #s(literal 27 binary64)) k)) 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
Simplified0.0%
Taylor expanded in b around inf
*-lowering-*.f6432.3%
Simplified32.3%
Taylor expanded in c around inf
Simplified57.3%
Final simplification91.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) (* x (* i -4.0)))) (t_2 (* (* j 27.0) k)))
(if (<= t_2 -2e+20)
(- (* b c) t_2)
(if (<= t_2 -1e-216)
t_1
(if (<= t_2 2e-290)
(+ (* b c) (* t (* a -4.0)))
(if (<= t_2 2e+150) t_1 (- (* -4.0 (* t a)) 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 = (b * c) + (x * (i * -4.0));
double t_2 = (j * 27.0) * k;
double tmp;
if (t_2 <= -2e+20) {
tmp = (b * c) - t_2;
} else if (t_2 <= -1e-216) {
tmp = t_1;
} else if (t_2 <= 2e-290) {
tmp = (b * c) + (t * (a * -4.0));
} else if (t_2 <= 2e+150) {
tmp = t_1;
} else {
tmp = (-4.0 * (t * a)) - 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 = (b * c) + (x * (i * (-4.0d0)))
t_2 = (j * 27.0d0) * k
if (t_2 <= (-2d+20)) then
tmp = (b * c) - t_2
else if (t_2 <= (-1d-216)) then
tmp = t_1
else if (t_2 <= 2d-290) then
tmp = (b * c) + (t * (a * (-4.0d0)))
else if (t_2 <= 2d+150) then
tmp = t_1
else
tmp = ((-4.0d0) * (t * a)) - 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 = (b * c) + (x * (i * -4.0));
double t_2 = (j * 27.0) * k;
double tmp;
if (t_2 <= -2e+20) {
tmp = (b * c) - t_2;
} else if (t_2 <= -1e-216) {
tmp = t_1;
} else if (t_2 <= 2e-290) {
tmp = (b * c) + (t * (a * -4.0));
} else if (t_2 <= 2e+150) {
tmp = t_1;
} else {
tmp = (-4.0 * (t * a)) - 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 = (b * c) + (x * (i * -4.0)) t_2 = (j * 27.0) * k tmp = 0 if t_2 <= -2e+20: tmp = (b * c) - t_2 elif t_2 <= -1e-216: tmp = t_1 elif t_2 <= 2e-290: tmp = (b * c) + (t * (a * -4.0)) elif t_2 <= 2e+150: tmp = t_1 else: tmp = (-4.0 * (t * a)) - 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(Float64(b * c) + Float64(x * Float64(i * -4.0))) t_2 = Float64(Float64(j * 27.0) * k) tmp = 0.0 if (t_2 <= -2e+20) tmp = Float64(Float64(b * c) - t_2); elseif (t_2 <= -1e-216) tmp = t_1; elseif (t_2 <= 2e-290) tmp = Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))); elseif (t_2 <= 2e+150) tmp = t_1; else tmp = Float64(Float64(-4.0 * Float64(t * a)) - 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 = (b * c) + (x * (i * -4.0));
t_2 = (j * 27.0) * k;
tmp = 0.0;
if (t_2 <= -2e+20)
tmp = (b * c) - t_2;
elseif (t_2 <= -1e-216)
tmp = t_1;
elseif (t_2 <= 2e-290)
tmp = (b * c) + (t * (a * -4.0));
elseif (t_2 <= 2e+150)
tmp = t_1;
else
tmp = (-4.0 * (t * a)) - 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[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+20], N[(N[(b * c), $MachinePrecision] - t$95$2), $MachinePrecision], If[LessEqual[t$95$2, -1e-216], t$95$1, If[LessEqual[t$95$2, 2e-290], N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+150], t$95$1, N[(N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision] - t$95$2), $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 := b \cdot c + x \cdot \left(i \cdot -4\right)\\
t_2 := \left(j \cdot 27\right) \cdot k\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+20}:\\
\;\;\;\;b \cdot c - t\_2\\
\mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-216}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{-290}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+150}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right) - t\_2\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -2e20Initial program 78.9%
Taylor expanded in b around inf
*-lowering-*.f6461.4%
Simplified61.4%
if -2e20 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -1e-216 or 2.0000000000000001e-290 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.99999999999999996e150Initial program 86.5%
Taylor expanded in t around 0
*-lowering-*.f6463.3%
Simplified63.3%
Taylor expanded in j around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6458.0%
Simplified58.0%
if -1e-216 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 2.0000000000000001e-290Initial program 95.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
Simplified95.9%
Taylor expanded in b around inf
*-lowering-*.f6484.5%
Simplified84.5%
Taylor expanded in x around 0
*-lowering-*.f6464.9%
Simplified64.9%
if 1.99999999999999996e150 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 74.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6478.2%
Simplified78.2%
Final simplification63.0%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (+ (* b c) (* x (* i -4.0)))) (t_2 (* (* j 27.0) k)))
(if (<= t_2 -2e+20)
(- (* b c) t_2)
(if (<= t_2 -1e-216)
t_1
(if (<= t_2 2e-290)
(+ (* b c) (* t (* a -4.0)))
(if (<= t_2 2e+150) t_1 (* c (+ b (* -27.0 (/ (* j k) 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 t_1 = (b * c) + (x * (i * -4.0));
double t_2 = (j * 27.0) * k;
double tmp;
if (t_2 <= -2e+20) {
tmp = (b * c) - t_2;
} else if (t_2 <= -1e-216) {
tmp = t_1;
} else if (t_2 <= 2e-290) {
tmp = (b * c) + (t * (a * -4.0));
} else if (t_2 <= 2e+150) {
tmp = t_1;
} else {
tmp = c * (b + (-27.0 * ((j * k) / 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (b * c) + (x * (i * (-4.0d0)))
t_2 = (j * 27.0d0) * k
if (t_2 <= (-2d+20)) then
tmp = (b * c) - t_2
else if (t_2 <= (-1d-216)) then
tmp = t_1
else if (t_2 <= 2d-290) then
tmp = (b * c) + (t * (a * (-4.0d0)))
else if (t_2 <= 2d+150) then
tmp = t_1
else
tmp = c * (b + ((-27.0d0) * ((j * k) / 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 t_1 = (b * c) + (x * (i * -4.0));
double t_2 = (j * 27.0) * k;
double tmp;
if (t_2 <= -2e+20) {
tmp = (b * c) - t_2;
} else if (t_2 <= -1e-216) {
tmp = t_1;
} else if (t_2 <= 2e-290) {
tmp = (b * c) + (t * (a * -4.0));
} else if (t_2 <= 2e+150) {
tmp = t_1;
} else {
tmp = c * (b + (-27.0 * ((j * k) / 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): t_1 = (b * c) + (x * (i * -4.0)) t_2 = (j * 27.0) * k tmp = 0 if t_2 <= -2e+20: tmp = (b * c) - t_2 elif t_2 <= -1e-216: tmp = t_1 elif t_2 <= 2e-290: tmp = (b * c) + (t * (a * -4.0)) elif t_2 <= 2e+150: tmp = t_1 else: tmp = c * (b + (-27.0 * ((j * k) / 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) t_1 = Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))) t_2 = Float64(Float64(j * 27.0) * k) tmp = 0.0 if (t_2 <= -2e+20) tmp = Float64(Float64(b * c) - t_2); elseif (t_2 <= -1e-216) tmp = t_1; elseif (t_2 <= 2e-290) tmp = Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))); elseif (t_2 <= 2e+150) tmp = t_1; else tmp = Float64(c * Float64(b + Float64(-27.0 * Float64(Float64(j * k) / 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)
t_1 = (b * c) + (x * (i * -4.0));
t_2 = (j * 27.0) * k;
tmp = 0.0;
if (t_2 <= -2e+20)
tmp = (b * c) - t_2;
elseif (t_2 <= -1e-216)
tmp = t_1;
elseif (t_2 <= 2e-290)
tmp = (b * c) + (t * (a * -4.0));
elseif (t_2 <= 2e+150)
tmp = t_1;
else
tmp = c * (b + (-27.0 * ((j * k) / 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_] := Block[{t$95$1 = N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+20], N[(N[(b * c), $MachinePrecision] - t$95$2), $MachinePrecision], If[LessEqual[t$95$2, -1e-216], t$95$1, If[LessEqual[t$95$2, 2e-290], N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+150], t$95$1, N[(c * N[(b + N[(-27.0 * N[(N[(j * k), $MachinePrecision] / c), $MachinePrecision]), $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 := b \cdot c + x \cdot \left(i \cdot -4\right)\\
t_2 := \left(j \cdot 27\right) \cdot k\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+20}:\\
\;\;\;\;b \cdot c - t\_2\\
\mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-216}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{-290}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+150}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(b + -27 \cdot \frac{j \cdot k}{c}\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -2e20Initial program 78.9%
Taylor expanded in b around inf
*-lowering-*.f6461.4%
Simplified61.4%
if -2e20 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -1e-216 or 2.0000000000000001e-290 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.99999999999999996e150Initial program 86.5%
Taylor expanded in t around 0
*-lowering-*.f6463.3%
Simplified63.3%
Taylor expanded in j around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6458.0%
Simplified58.0%
if -1e-216 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 2.0000000000000001e-290Initial program 95.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
Simplified95.9%
Taylor expanded in b around inf
*-lowering-*.f6484.5%
Simplified84.5%
Taylor expanded in x around 0
*-lowering-*.f6464.9%
Simplified64.9%
if 1.99999999999999996e150 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 74.9%
Taylor expanded in b around inf
*-lowering-*.f6465.8%
Simplified65.8%
Taylor expanded in c around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6474.0%
Simplified74.0%
Final simplification62.4%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (+ (* b c) (* x (* i -4.0)))) (t_2 (* (* j 27.0) k)))
(if (<= t_2 -2e+20)
(- (* b c) t_2)
(if (<= t_2 -1e-216)
t_1
(if (<= t_2 2e-290)
(+ (* b c) (* t (* a -4.0)))
(if (<= t_2 2e+150) t_1 (* k (* j -27.0))))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = (b * c) + (x * (i * -4.0));
double t_2 = (j * 27.0) * k;
double tmp;
if (t_2 <= -2e+20) {
tmp = (b * c) - t_2;
} else if (t_2 <= -1e-216) {
tmp = t_1;
} else if (t_2 <= 2e-290) {
tmp = (b * c) + (t * (a * -4.0));
} else if (t_2 <= 2e+150) {
tmp = t_1;
} else {
tmp = k * (j * -27.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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (b * c) + (x * (i * (-4.0d0)))
t_2 = (j * 27.0d0) * k
if (t_2 <= (-2d+20)) then
tmp = (b * c) - t_2
else if (t_2 <= (-1d-216)) then
tmp = t_1
else if (t_2 <= 2d-290) then
tmp = (b * c) + (t * (a * (-4.0d0)))
else if (t_2 <= 2d+150) then
tmp = t_1
else
tmp = k * (j * (-27.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 t_1 = (b * c) + (x * (i * -4.0));
double t_2 = (j * 27.0) * k;
double tmp;
if (t_2 <= -2e+20) {
tmp = (b * c) - t_2;
} else if (t_2 <= -1e-216) {
tmp = t_1;
} else if (t_2 <= 2e-290) {
tmp = (b * c) + (t * (a * -4.0));
} else if (t_2 <= 2e+150) {
tmp = t_1;
} else {
tmp = k * (j * -27.0);
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = (b * c) + (x * (i * -4.0)) t_2 = (j * 27.0) * k tmp = 0 if t_2 <= -2e+20: tmp = (b * c) - t_2 elif t_2 <= -1e-216: tmp = t_1 elif t_2 <= 2e-290: tmp = (b * c) + (t * (a * -4.0)) elif t_2 <= 2e+150: tmp = t_1 else: tmp = k * (j * -27.0) return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))) t_2 = Float64(Float64(j * 27.0) * k) tmp = 0.0 if (t_2 <= -2e+20) tmp = Float64(Float64(b * c) - t_2); elseif (t_2 <= -1e-216) tmp = t_1; elseif (t_2 <= 2e-290) tmp = Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))); elseif (t_2 <= 2e+150) tmp = t_1; else tmp = Float64(k * Float64(j * -27.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)
t_1 = (b * c) + (x * (i * -4.0));
t_2 = (j * 27.0) * k;
tmp = 0.0;
if (t_2 <= -2e+20)
tmp = (b * c) - t_2;
elseif (t_2 <= -1e-216)
tmp = t_1;
elseif (t_2 <= 2e-290)
tmp = (b * c) + (t * (a * -4.0));
elseif (t_2 <= 2e+150)
tmp = t_1;
else
tmp = k * (j * -27.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_] := Block[{t$95$1 = N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+20], N[(N[(b * c), $MachinePrecision] - t$95$2), $MachinePrecision], If[LessEqual[t$95$2, -1e-216], t$95$1, If[LessEqual[t$95$2, 2e-290], N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+150], t$95$1, N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := b \cdot c + x \cdot \left(i \cdot -4\right)\\
t_2 := \left(j \cdot 27\right) \cdot k\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+20}:\\
\;\;\;\;b \cdot c - t\_2\\
\mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-216}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{-290}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+150}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;k \cdot \left(j \cdot -27\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -2e20Initial program 78.9%
Taylor expanded in b around inf
*-lowering-*.f6461.4%
Simplified61.4%
if -2e20 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < -1e-216 or 2.0000000000000001e-290 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 1.99999999999999996e150Initial program 86.5%
Taylor expanded in t around 0
*-lowering-*.f6463.3%
Simplified63.3%
Taylor expanded in j around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6458.0%
Simplified58.0%
if -1e-216 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) < 2.0000000000000001e-290Initial program 95.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
Simplified95.9%
Taylor expanded in b around inf
*-lowering-*.f6484.5%
Simplified84.5%
Taylor expanded in x around 0
*-lowering-*.f6464.9%
Simplified64.9%
if 1.99999999999999996e150 < (*.f64 (*.f64 j #s(literal 27 binary64)) k) Initial program 74.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
Simplified74.8%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6468.6%
Simplified68.6%
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6468.7%
Applied egg-rr68.7%
Final simplification61.6%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(if (<= k -1.7e-93)
(* j (* k -27.0))
(if (<= k -9.5e-272)
(* -4.0 (* x i))
(if (<= k 9.5e-271)
(* b c)
(if (<= k 5.2e-138)
(* -4.0 (* t a))
(if (<= k 3.6e-86)
(* b c)
(if (<= k 5.6e+82)
(* (* y z) (* (* x 18.0) t))
(* k (* j -27.0)))))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if (k <= -1.7e-93) {
tmp = j * (k * -27.0);
} else if (k <= -9.5e-272) {
tmp = -4.0 * (x * i);
} else if (k <= 9.5e-271) {
tmp = b * c;
} else if (k <= 5.2e-138) {
tmp = -4.0 * (t * a);
} else if (k <= 3.6e-86) {
tmp = b * c;
} else if (k <= 5.6e+82) {
tmp = (y * z) * ((x * 18.0) * t);
} else {
tmp = k * (j * -27.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 (k <= (-1.7d-93)) then
tmp = j * (k * (-27.0d0))
else if (k <= (-9.5d-272)) then
tmp = (-4.0d0) * (x * i)
else if (k <= 9.5d-271) then
tmp = b * c
else if (k <= 5.2d-138) then
tmp = (-4.0d0) * (t * a)
else if (k <= 3.6d-86) then
tmp = b * c
else if (k <= 5.6d+82) then
tmp = (y * z) * ((x * 18.0d0) * t)
else
tmp = k * (j * (-27.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 (k <= -1.7e-93) {
tmp = j * (k * -27.0);
} else if (k <= -9.5e-272) {
tmp = -4.0 * (x * i);
} else if (k <= 9.5e-271) {
tmp = b * c;
} else if (k <= 5.2e-138) {
tmp = -4.0 * (t * a);
} else if (k <= 3.6e-86) {
tmp = b * c;
} else if (k <= 5.6e+82) {
tmp = (y * z) * ((x * 18.0) * t);
} else {
tmp = k * (j * -27.0);
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): tmp = 0 if k <= -1.7e-93: tmp = j * (k * -27.0) elif k <= -9.5e-272: tmp = -4.0 * (x * i) elif k <= 9.5e-271: tmp = b * c elif k <= 5.2e-138: tmp = -4.0 * (t * a) elif k <= 3.6e-86: tmp = b * c elif k <= 5.6e+82: tmp = (y * z) * ((x * 18.0) * t) else: tmp = k * (j * -27.0) return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (k <= -1.7e-93) tmp = Float64(j * Float64(k * -27.0)); elseif (k <= -9.5e-272) tmp = Float64(-4.0 * Float64(x * i)); elseif (k <= 9.5e-271) tmp = Float64(b * c); elseif (k <= 5.2e-138) tmp = Float64(-4.0 * Float64(t * a)); elseif (k <= 3.6e-86) tmp = Float64(b * c); elseif (k <= 5.6e+82) tmp = Float64(Float64(y * z) * Float64(Float64(x * 18.0) * t)); else tmp = Float64(k * Float64(j * -27.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 (k <= -1.7e-93)
tmp = j * (k * -27.0);
elseif (k <= -9.5e-272)
tmp = -4.0 * (x * i);
elseif (k <= 9.5e-271)
tmp = b * c;
elseif (k <= 5.2e-138)
tmp = -4.0 * (t * a);
elseif (k <= 3.6e-86)
tmp = b * c;
elseif (k <= 5.6e+82)
tmp = (y * z) * ((x * 18.0) * t);
else
tmp = k * (j * -27.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[k, -1.7e-93], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -9.5e-272], N[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 9.5e-271], N[(b * c), $MachinePrecision], If[LessEqual[k, 5.2e-138], N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3.6e-86], N[(b * c), $MachinePrecision], If[LessEqual[k, 5.6e+82], N[(N[(y * z), $MachinePrecision] * N[(N[(x * 18.0), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.7 \cdot 10^{-93}:\\
\;\;\;\;j \cdot \left(k \cdot -27\right)\\
\mathbf{elif}\;k \leq -9.5 \cdot 10^{-272}:\\
\;\;\;\;-4 \cdot \left(x \cdot i\right)\\
\mathbf{elif}\;k \leq 9.5 \cdot 10^{-271}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 5.2 \cdot 10^{-138}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right)\\
\mathbf{elif}\;k \leq 3.6 \cdot 10^{-86}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 5.6 \cdot 10^{+82}:\\
\;\;\;\;\left(y \cdot z\right) \cdot \left(\left(x \cdot 18\right) \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;k \cdot \left(j \cdot -27\right)\\
\end{array}
\end{array}
if k < -1.70000000000000001e-93Initial program 80.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
Simplified80.8%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6436.0%
Simplified36.0%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6435.9%
Applied egg-rr35.9%
if -1.70000000000000001e-93 < k < -9.50000000000000024e-272Initial program 93.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
Simplified93.4%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6431.8%
Simplified31.8%
if -9.50000000000000024e-272 < k < 9.50000000000000103e-271 or 5.2e-138 < k < 3.59999999999999966e-86Initial program 94.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
Simplified94.9%
Taylor expanded in b around inf
*-lowering-*.f6456.7%
Simplified56.7%
if 9.50000000000000103e-271 < k < 5.2e-138Initial program 96.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
Simplified92.5%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6443.9%
Simplified43.9%
if 3.59999999999999966e-86 < k < 5.6000000000000001e82Initial program 77.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
Simplified77.4%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6438.8%
Simplified38.8%
if 5.6000000000000001e82 < k Initial program 79.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
Simplified79.6%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6454.5%
Simplified54.5%
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6454.7%
Applied egg-rr54.7%
Final simplification41.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
(if (<= k -1.75e-93)
(* j (* k -27.0))
(if (<= k -3.7e-272)
(* -4.0 (* x i))
(if (<= k 1.4e-269)
(* b c)
(if (<= k 4.8e-134)
(* -4.0 (* t a))
(if (<= k 2.3e-84)
(* b c)
(if (<= k 5.3e+82)
(* t (* 18.0 (* x (* y z))))
(* k (* j -27.0)))))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if (k <= -1.75e-93) {
tmp = j * (k * -27.0);
} else if (k <= -3.7e-272) {
tmp = -4.0 * (x * i);
} else if (k <= 1.4e-269) {
tmp = b * c;
} else if (k <= 4.8e-134) {
tmp = -4.0 * (t * a);
} else if (k <= 2.3e-84) {
tmp = b * c;
} else if (k <= 5.3e+82) {
tmp = t * (18.0 * (x * (y * z)));
} else {
tmp = k * (j * -27.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 (k <= (-1.75d-93)) then
tmp = j * (k * (-27.0d0))
else if (k <= (-3.7d-272)) then
tmp = (-4.0d0) * (x * i)
else if (k <= 1.4d-269) then
tmp = b * c
else if (k <= 4.8d-134) then
tmp = (-4.0d0) * (t * a)
else if (k <= 2.3d-84) then
tmp = b * c
else if (k <= 5.3d+82) then
tmp = t * (18.0d0 * (x * (y * z)))
else
tmp = k * (j * (-27.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 (k <= -1.75e-93) {
tmp = j * (k * -27.0);
} else if (k <= -3.7e-272) {
tmp = -4.0 * (x * i);
} else if (k <= 1.4e-269) {
tmp = b * c;
} else if (k <= 4.8e-134) {
tmp = -4.0 * (t * a);
} else if (k <= 2.3e-84) {
tmp = b * c;
} else if (k <= 5.3e+82) {
tmp = t * (18.0 * (x * (y * z)));
} else {
tmp = k * (j * -27.0);
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): tmp = 0 if k <= -1.75e-93: tmp = j * (k * -27.0) elif k <= -3.7e-272: tmp = -4.0 * (x * i) elif k <= 1.4e-269: tmp = b * c elif k <= 4.8e-134: tmp = -4.0 * (t * a) elif k <= 2.3e-84: tmp = b * c elif k <= 5.3e+82: tmp = t * (18.0 * (x * (y * z))) else: tmp = k * (j * -27.0) return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (k <= -1.75e-93) tmp = Float64(j * Float64(k * -27.0)); elseif (k <= -3.7e-272) tmp = Float64(-4.0 * Float64(x * i)); elseif (k <= 1.4e-269) tmp = Float64(b * c); elseif (k <= 4.8e-134) tmp = Float64(-4.0 * Float64(t * a)); elseif (k <= 2.3e-84) tmp = Float64(b * c); elseif (k <= 5.3e+82) tmp = Float64(t * Float64(18.0 * Float64(x * Float64(y * z)))); else tmp = Float64(k * Float64(j * -27.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 (k <= -1.75e-93)
tmp = j * (k * -27.0);
elseif (k <= -3.7e-272)
tmp = -4.0 * (x * i);
elseif (k <= 1.4e-269)
tmp = b * c;
elseif (k <= 4.8e-134)
tmp = -4.0 * (t * a);
elseif (k <= 2.3e-84)
tmp = b * c;
elseif (k <= 5.3e+82)
tmp = t * (18.0 * (x * (y * z)));
else
tmp = k * (j * -27.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[k, -1.75e-93], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -3.7e-272], N[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 1.4e-269], N[(b * c), $MachinePrecision], If[LessEqual[k, 4.8e-134], N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.3e-84], N[(b * c), $MachinePrecision], If[LessEqual[k, 5.3e+82], N[(t * N[(18.0 * N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.75 \cdot 10^{-93}:\\
\;\;\;\;j \cdot \left(k \cdot -27\right)\\
\mathbf{elif}\;k \leq -3.7 \cdot 10^{-272}:\\
\;\;\;\;-4 \cdot \left(x \cdot i\right)\\
\mathbf{elif}\;k \leq 1.4 \cdot 10^{-269}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 4.8 \cdot 10^{-134}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right)\\
\mathbf{elif}\;k \leq 2.3 \cdot 10^{-84}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 5.3 \cdot 10^{+82}:\\
\;\;\;\;t \cdot \left(18 \cdot \left(x \cdot \left(y \cdot z\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;k \cdot \left(j \cdot -27\right)\\
\end{array}
\end{array}
if k < -1.75e-93Initial program 80.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
Simplified80.8%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6436.0%
Simplified36.0%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6435.9%
Applied egg-rr35.9%
if -1.75e-93 < k < -3.6999999999999997e-272Initial program 93.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
Simplified93.4%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6431.8%
Simplified31.8%
if -3.6999999999999997e-272 < k < 1.39999999999999997e-269 or 4.80000000000000019e-134 < k < 2.29999999999999981e-84Initial program 94.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
Simplified94.9%
Taylor expanded in b around inf
*-lowering-*.f6456.7%
Simplified56.7%
if 1.39999999999999997e-269 < k < 4.80000000000000019e-134Initial program 96.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
Simplified92.5%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6443.9%
Simplified43.9%
if 2.29999999999999981e-84 < k < 5.29999999999999977e82Initial program 77.4%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6477.6%
Applied egg-rr77.6%
Taylor expanded in x around inf
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
+-commutativeN/A
Simplified75.5%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6438.7%
Simplified38.7%
if 5.29999999999999977e82 < k Initial program 79.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
Simplified79.6%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6454.5%
Simplified54.5%
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6454.7%
Applied egg-rr54.7%
Final simplification41.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 (* (* j 27.0) k)) (t_2 (* y (* z (* 18.0 t)))))
(if (<= x -7.2e+105)
(- (* x (+ (* i -4.0) (+ t_2 (/ (+ (* b c) (* -4.0 (* t a))) x)))) t_1)
(if (<= x 9.5e+34)
(+
(* t (+ (* a -4.0) (* y (* (* x 18.0) z))))
(+ (* -27.0 (* j k)) (+ (* b c) (* x (* i -4.0)))))
(- (+ (* b c) (* x (+ (* i -4.0) 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 = (j * 27.0) * k;
double t_2 = y * (z * (18.0 * t));
double tmp;
if (x <= -7.2e+105) {
tmp = (x * ((i * -4.0) + (t_2 + (((b * c) + (-4.0 * (t * a))) / x)))) - t_1;
} else if (x <= 9.5e+34) {
tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else {
tmp = ((b * c) + (x * ((i * -4.0) + t_2))) - 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 = (j * 27.0d0) * k
t_2 = y * (z * (18.0d0 * t))
if (x <= (-7.2d+105)) then
tmp = (x * ((i * (-4.0d0)) + (t_2 + (((b * c) + ((-4.0d0) * (t * a))) / x)))) - t_1
else if (x <= 9.5d+34) then
tmp = (t * ((a * (-4.0d0)) + (y * ((x * 18.0d0) * z)))) + (((-27.0d0) * (j * k)) + ((b * c) + (x * (i * (-4.0d0)))))
else
tmp = ((b * c) + (x * ((i * (-4.0d0)) + t_2))) - 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 t_2 = y * (z * (18.0 * t));
double tmp;
if (x <= -7.2e+105) {
tmp = (x * ((i * -4.0) + (t_2 + (((b * c) + (-4.0 * (t * a))) / x)))) - t_1;
} else if (x <= 9.5e+34) {
tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else {
tmp = ((b * c) + (x * ((i * -4.0) + t_2))) - 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 t_2 = y * (z * (18.0 * t)) tmp = 0 if x <= -7.2e+105: tmp = (x * ((i * -4.0) + (t_2 + (((b * c) + (-4.0 * (t * a))) / x)))) - t_1 elif x <= 9.5e+34: tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) else: tmp = ((b * c) + (x * ((i * -4.0) + t_2))) - 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) t_2 = Float64(y * Float64(z * Float64(18.0 * t))) tmp = 0.0 if (x <= -7.2e+105) tmp = Float64(Float64(x * Float64(Float64(i * -4.0) + Float64(t_2 + Float64(Float64(Float64(b * c) + Float64(-4.0 * Float64(t * a))) / x)))) - t_1); elseif (x <= 9.5e+34) tmp = Float64(Float64(t * Float64(Float64(a * -4.0) + Float64(y * Float64(Float64(x * 18.0) * z)))) + Float64(Float64(-27.0 * Float64(j * k)) + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))))); else tmp = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(i * -4.0) + t_2))) - 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;
t_2 = y * (z * (18.0 * t));
tmp = 0.0;
if (x <= -7.2e+105)
tmp = (x * ((i * -4.0) + (t_2 + (((b * c) + (-4.0 * (t * a))) / x)))) - t_1;
elseif (x <= 9.5e+34)
tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
else
tmp = ((b * c) + (x * ((i * -4.0) + t_2))) - 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]}, Block[{t$95$2 = N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -7.2e+105], N[(N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(t$95$2 + N[(N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 9.5e+34], N[(N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(y * N[(N[(x * 18.0), $MachinePrecision] * z), $MachinePrecision]), $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], N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(i * -4.0), $MachinePrecision] + t$95$2), $MachinePrecision]), $MachinePrecision]), $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\\
t_2 := y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\\
\mathbf{if}\;x \leq -7.2 \cdot 10^{+105}:\\
\;\;\;\;x \cdot \left(i \cdot -4 + \left(t\_2 + \frac{b \cdot c + -4 \cdot \left(t \cdot a\right)}{x}\right)\right) - t\_1\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{+34}:\\
\;\;\;\;t \cdot \left(a \cdot -4 + y \cdot \left(\left(x \cdot 18\right) \cdot z\right)\right) + \left(-27 \cdot \left(j \cdot k\right) + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot c + x \cdot \left(i \cdot -4 + t\_2\right)\right) - t\_1\\
\end{array}
\end{array}
if x < -7.1999999999999998e105Initial program 60.9%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6477.4%
Applied egg-rr77.4%
Taylor expanded in x around inf
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
+-commutativeN/A
Simplified79.8%
if -7.1999999999999998e105 < x < 9.4999999999999999e34Initial program 95.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
Simplified94.6%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6495.2%
Applied egg-rr95.2%
if 9.4999999999999999e34 < x Initial program 75.3%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6487.4%
Applied egg-rr87.4%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Simplified92.2%
Final simplification92.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 (* (* j 27.0) k)))
(if (<= x -9.2e+46)
(* x (+ (* i -4.0) (* y (* z (* 18.0 t)))))
(if (<= x -7.8e-222)
(- (* -4.0 (* t a)) t_1)
(if (<= x 1.8e-135)
(+ (* b c) (* t (* a -4.0)))
(if (<= x 3.8e-9)
(- (* b c) t_1)
(if (<= x 3.3e+168)
(- (* x (* i -4.0)) (* j (* 27.0 k)))
(* x (+ (* i -4.0) (* 18.0 (* z (* y t))))))))))))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 (x <= -9.2e+46) {
tmp = x * ((i * -4.0) + (y * (z * (18.0 * t))));
} else if (x <= -7.8e-222) {
tmp = (-4.0 * (t * a)) - t_1;
} else if (x <= 1.8e-135) {
tmp = (b * c) + (t * (a * -4.0));
} else if (x <= 3.8e-9) {
tmp = (b * c) - t_1;
} else if (x <= 3.3e+168) {
tmp = (x * (i * -4.0)) - (j * (27.0 * k));
} else {
tmp = x * ((i * -4.0) + (18.0 * (z * (y * t))));
}
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 (x <= (-9.2d+46)) then
tmp = x * ((i * (-4.0d0)) + (y * (z * (18.0d0 * t))))
else if (x <= (-7.8d-222)) then
tmp = ((-4.0d0) * (t * a)) - t_1
else if (x <= 1.8d-135) then
tmp = (b * c) + (t * (a * (-4.0d0)))
else if (x <= 3.8d-9) then
tmp = (b * c) - t_1
else if (x <= 3.3d+168) then
tmp = (x * (i * (-4.0d0))) - (j * (27.0d0 * k))
else
tmp = x * ((i * (-4.0d0)) + (18.0d0 * (z * (y * t))))
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 (x <= -9.2e+46) {
tmp = x * ((i * -4.0) + (y * (z * (18.0 * t))));
} else if (x <= -7.8e-222) {
tmp = (-4.0 * (t * a)) - t_1;
} else if (x <= 1.8e-135) {
tmp = (b * c) + (t * (a * -4.0));
} else if (x <= 3.8e-9) {
tmp = (b * c) - t_1;
} else if (x <= 3.3e+168) {
tmp = (x * (i * -4.0)) - (j * (27.0 * k));
} else {
tmp = x * ((i * -4.0) + (18.0 * (z * (y * t))));
}
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 x <= -9.2e+46: tmp = x * ((i * -4.0) + (y * (z * (18.0 * t)))) elif x <= -7.8e-222: tmp = (-4.0 * (t * a)) - t_1 elif x <= 1.8e-135: tmp = (b * c) + (t * (a * -4.0)) elif x <= 3.8e-9: tmp = (b * c) - t_1 elif x <= 3.3e+168: tmp = (x * (i * -4.0)) - (j * (27.0 * k)) else: tmp = x * ((i * -4.0) + (18.0 * (z * (y * t)))) 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 (x <= -9.2e+46) tmp = Float64(x * Float64(Float64(i * -4.0) + Float64(y * Float64(z * Float64(18.0 * t))))); elseif (x <= -7.8e-222) tmp = Float64(Float64(-4.0 * Float64(t * a)) - t_1); elseif (x <= 1.8e-135) tmp = Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))); elseif (x <= 3.8e-9) tmp = Float64(Float64(b * c) - t_1); elseif (x <= 3.3e+168) tmp = Float64(Float64(x * Float64(i * -4.0)) - Float64(j * Float64(27.0 * k))); else tmp = Float64(x * Float64(Float64(i * -4.0) + Float64(18.0 * Float64(z * Float64(y * t))))); 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 (x <= -9.2e+46)
tmp = x * ((i * -4.0) + (y * (z * (18.0 * t))));
elseif (x <= -7.8e-222)
tmp = (-4.0 * (t * a)) - t_1;
elseif (x <= 1.8e-135)
tmp = (b * c) + (t * (a * -4.0));
elseif (x <= 3.8e-9)
tmp = (b * c) - t_1;
elseif (x <= 3.3e+168)
tmp = (x * (i * -4.0)) - (j * (27.0 * k));
else
tmp = x * ((i * -4.0) + (18.0 * (z * (y * t))));
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[x, -9.2e+46], N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7.8e-222], N[(N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 1.8e-135], N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.8e-9], N[(N[(b * c), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 3.3e+168], N[(N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision] - N[(j * N[(27.0 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(18.0 * N[(z * N[(y * t), $MachinePrecision]), $MachinePrecision]), $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(j \cdot 27\right) \cdot k\\
\mathbf{if}\;x \leq -9.2 \cdot 10^{+46}:\\
\;\;\;\;x \cdot \left(i \cdot -4 + y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\right)\\
\mathbf{elif}\;x \leq -7.8 \cdot 10^{-222}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right) - t\_1\\
\mathbf{elif}\;x \leq 1.8 \cdot 10^{-135}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{-9}:\\
\;\;\;\;b \cdot c - t\_1\\
\mathbf{elif}\;x \leq 3.3 \cdot 10^{+168}:\\
\;\;\;\;x \cdot \left(i \cdot -4\right) - j \cdot \left(27 \cdot k\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(i \cdot -4 + 18 \cdot \left(z \cdot \left(y \cdot t\right)\right)\right)\\
\end{array}
\end{array}
if x < -9.2000000000000002e46Initial program 66.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
Simplified66.1%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6469.5%
Applied egg-rr69.5%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6456.7%
Simplified56.7%
if -9.2000000000000002e46 < x < -7.8000000000000002e-222Initial program 97.8%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6460.9%
Simplified60.9%
if -7.8000000000000002e-222 < x < 1.79999999999999989e-135Initial program 96.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
Simplified94.1%
Taylor expanded in b around inf
*-lowering-*.f6470.2%
Simplified70.2%
Taylor expanded in x around 0
*-lowering-*.f6469.9%
Simplified69.9%
if 1.79999999999999989e-135 < x < 3.80000000000000011e-9Initial program 96.2%
Taylor expanded in b around inf
*-lowering-*.f6474.9%
Simplified74.9%
if 3.80000000000000011e-9 < x < 3.2999999999999999e168Initial program 76.0%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6461.4%
Simplified61.4%
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6461.4%
Applied egg-rr61.4%
if 3.2999999999999999e168 < x Initial program 80.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
Simplified80.6%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6491.7%
Simplified91.7%
Final simplification67.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 (* (* j 27.0) k))
(t_2 (* x (+ (* i -4.0) (* 18.0 (* z (* y t)))))))
(if (<= x -1.06e+49)
t_2
(if (<= x -7.4e-222)
(- (* -4.0 (* t a)) t_1)
(if (<= x 5.3e-135)
(+ (* b c) (* t (* a -4.0)))
(if (<= x 3.9e-16)
(- (* b c) t_1)
(if (<= x 3.15e+168)
(- (* x (* i -4.0)) (* j (* 27.0 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 = (j * 27.0) * k;
double t_2 = x * ((i * -4.0) + (18.0 * (z * (y * t))));
double tmp;
if (x <= -1.06e+49) {
tmp = t_2;
} else if (x <= -7.4e-222) {
tmp = (-4.0 * (t * a)) - t_1;
} else if (x <= 5.3e-135) {
tmp = (b * c) + (t * (a * -4.0));
} else if (x <= 3.9e-16) {
tmp = (b * c) - t_1;
} else if (x <= 3.15e+168) {
tmp = (x * (i * -4.0)) - (j * (27.0 * 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 = (j * 27.0d0) * k
t_2 = x * ((i * (-4.0d0)) + (18.0d0 * (z * (y * t))))
if (x <= (-1.06d+49)) then
tmp = t_2
else if (x <= (-7.4d-222)) then
tmp = ((-4.0d0) * (t * a)) - t_1
else if (x <= 5.3d-135) then
tmp = (b * c) + (t * (a * (-4.0d0)))
else if (x <= 3.9d-16) then
tmp = (b * c) - t_1
else if (x <= 3.15d+168) then
tmp = (x * (i * (-4.0d0))) - (j * (27.0d0 * 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 = (j * 27.0) * k;
double t_2 = x * ((i * -4.0) + (18.0 * (z * (y * t))));
double tmp;
if (x <= -1.06e+49) {
tmp = t_2;
} else if (x <= -7.4e-222) {
tmp = (-4.0 * (t * a)) - t_1;
} else if (x <= 5.3e-135) {
tmp = (b * c) + (t * (a * -4.0));
} else if (x <= 3.9e-16) {
tmp = (b * c) - t_1;
} else if (x <= 3.15e+168) {
tmp = (x * (i * -4.0)) - (j * (27.0 * 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 = (j * 27.0) * k t_2 = x * ((i * -4.0) + (18.0 * (z * (y * t)))) tmp = 0 if x <= -1.06e+49: tmp = t_2 elif x <= -7.4e-222: tmp = (-4.0 * (t * a)) - t_1 elif x <= 5.3e-135: tmp = (b * c) + (t * (a * -4.0)) elif x <= 3.9e-16: tmp = (b * c) - t_1 elif x <= 3.15e+168: tmp = (x * (i * -4.0)) - (j * (27.0 * 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(Float64(j * 27.0) * k) t_2 = Float64(x * Float64(Float64(i * -4.0) + Float64(18.0 * Float64(z * Float64(y * t))))) tmp = 0.0 if (x <= -1.06e+49) tmp = t_2; elseif (x <= -7.4e-222) tmp = Float64(Float64(-4.0 * Float64(t * a)) - t_1); elseif (x <= 5.3e-135) tmp = Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))); elseif (x <= 3.9e-16) tmp = Float64(Float64(b * c) - t_1); elseif (x <= 3.15e+168) tmp = Float64(Float64(x * Float64(i * -4.0)) - Float64(j * Float64(27.0 * 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 = (j * 27.0) * k;
t_2 = x * ((i * -4.0) + (18.0 * (z * (y * t))));
tmp = 0.0;
if (x <= -1.06e+49)
tmp = t_2;
elseif (x <= -7.4e-222)
tmp = (-4.0 * (t * a)) - t_1;
elseif (x <= 5.3e-135)
tmp = (b * c) + (t * (a * -4.0));
elseif (x <= 3.9e-16)
tmp = (b * c) - t_1;
elseif (x <= 3.15e+168)
tmp = (x * (i * -4.0)) - (j * (27.0 * 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[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(18.0 * N[(z * N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.06e+49], t$95$2, If[LessEqual[x, -7.4e-222], N[(N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 5.3e-135], N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.9e-16], N[(N[(b * c), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 3.15e+168], N[(N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision] - N[(j * N[(27.0 * 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 := \left(j \cdot 27\right) \cdot k\\
t_2 := x \cdot \left(i \cdot -4 + 18 \cdot \left(z \cdot \left(y \cdot t\right)\right)\right)\\
\mathbf{if}\;x \leq -1.06 \cdot 10^{+49}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -7.4 \cdot 10^{-222}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right) - t\_1\\
\mathbf{elif}\;x \leq 5.3 \cdot 10^{-135}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{elif}\;x \leq 3.9 \cdot 10^{-16}:\\
\;\;\;\;b \cdot c - t\_1\\
\mathbf{elif}\;x \leq 3.15 \cdot 10^{+168}:\\
\;\;\;\;x \cdot \left(i \cdot -4\right) - j \cdot \left(27 \cdot k\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.06e49 or 3.1499999999999998e168 < x Initial program 71.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
Simplified71.6%
Taylor expanded in x around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6471.5%
Simplified71.5%
if -1.06e49 < x < -7.3999999999999997e-222Initial program 97.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6459.7%
Simplified59.7%
if -7.3999999999999997e-222 < x < 5.3e-135Initial program 96.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
Simplified94.1%
Taylor expanded in b around inf
*-lowering-*.f6470.2%
Simplified70.2%
Taylor expanded in x around 0
*-lowering-*.f6469.9%
Simplified69.9%
if 5.3e-135 < x < 3.89999999999999977e-16Initial program 96.2%
Taylor expanded in b around inf
*-lowering-*.f6474.9%
Simplified74.9%
if 3.89999999999999977e-16 < x < 3.1499999999999998e168Initial program 76.0%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6461.4%
Simplified61.4%
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6461.4%
Applied egg-rr61.4%
Final simplification67.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 (* (* j 27.0) k)))
(if (<= x -9.5e+253)
(* t (+ (* a -4.0) (* x (* 18.0 (* y z)))))
(if (<= x -2.2e-21)
(- (+ (* b c) (* x (+ (* i -4.0) (* y (* z (* 18.0 t)))))) t_1)
(if (<= x 6e-37)
(- (+ (* b c) (* -4.0 (* t a))) t_1)
(- (+ (* b c) (* x (+ (* i -4.0) (* 18.0 (* z (* y 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 * 27.0) * k;
double tmp;
if (x <= -9.5e+253) {
tmp = t * ((a * -4.0) + (x * (18.0 * (y * z))));
} else if (x <= -2.2e-21) {
tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - t_1;
} else if (x <= 6e-37) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} else {
tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - 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 (x <= (-9.5d+253)) then
tmp = t * ((a * (-4.0d0)) + (x * (18.0d0 * (y * z))))
else if (x <= (-2.2d-21)) then
tmp = ((b * c) + (x * ((i * (-4.0d0)) + (y * (z * (18.0d0 * t)))))) - t_1
else if (x <= 6d-37) then
tmp = ((b * c) + ((-4.0d0) * (t * a))) - t_1
else
tmp = ((b * c) + (x * ((i * (-4.0d0)) + (18.0d0 * (z * (y * t)))))) - 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 (x <= -9.5e+253) {
tmp = t * ((a * -4.0) + (x * (18.0 * (y * z))));
} else if (x <= -2.2e-21) {
tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - t_1;
} else if (x <= 6e-37) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} else {
tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - 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 x <= -9.5e+253: tmp = t * ((a * -4.0) + (x * (18.0 * (y * z)))) elif x <= -2.2e-21: tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - t_1 elif x <= 6e-37: tmp = ((b * c) + (-4.0 * (t * a))) - t_1 else: tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - 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 (x <= -9.5e+253) tmp = Float64(t * Float64(Float64(a * -4.0) + Float64(x * Float64(18.0 * Float64(y * z))))); elseif (x <= -2.2e-21) tmp = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(i * -4.0) + Float64(y * Float64(z * Float64(18.0 * t)))))) - t_1); elseif (x <= 6e-37) tmp = Float64(Float64(Float64(b * c) + Float64(-4.0 * Float64(t * a))) - t_1); else tmp = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(i * -4.0) + Float64(18.0 * Float64(z * Float64(y * t)))))) - 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 (x <= -9.5e+253)
tmp = t * ((a * -4.0) + (x * (18.0 * (y * z))));
elseif (x <= -2.2e-21)
tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - t_1;
elseif (x <= 6e-37)
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
else
tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - 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[x, -9.5e+253], N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.2e-21], N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 6e-37], N[(N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(18.0 * N[(z * N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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}\;x \leq -9.5 \cdot 10^{+253}:\\
\;\;\;\;t \cdot \left(a \cdot -4 + x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\
\mathbf{elif}\;x \leq -2.2 \cdot 10^{-21}:\\
\;\;\;\;\left(b \cdot c + x \cdot \left(i \cdot -4 + y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\right)\right) - t\_1\\
\mathbf{elif}\;x \leq 6 \cdot 10^{-37}:\\
\;\;\;\;\left(b \cdot c + -4 \cdot \left(t \cdot a\right)\right) - t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot c + x \cdot \left(i \cdot -4 + 18 \cdot \left(z \cdot \left(y \cdot t\right)\right)\right)\right) - t\_1\\
\end{array}
\end{array}
if x < -9.50000000000000005e253Initial program 51.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
Simplified51.2%
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-*.f6490.8%
Simplified90.8%
if -9.50000000000000005e253 < x < -2.2000000000000001e-21Initial program 72.1%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6482.9%
Applied egg-rr82.9%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Simplified74.4%
if -2.2000000000000001e-21 < x < 6e-37Initial program 97.3%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6485.8%
Simplified85.8%
if 6e-37 < x Initial program 79.4%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Simplified89.7%
Final simplification84.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 (* (* j 27.0) k))
(t_2 (- (+ (* b c) (* x (+ (* i -4.0) (* 18.0 (* z (* y t)))))) t_1)))
(if (<= x -9.5e+253)
(* t (+ (* a -4.0) (* x (* 18.0 (* y z)))))
(if (<= x -2.5e-19)
t_2
(if (<= x 2.7e-36) (- (+ (* b c) (* -4.0 (* t a))) t_1) 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 = (j * 27.0) * k;
double t_2 = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - t_1;
double tmp;
if (x <= -9.5e+253) {
tmp = t * ((a * -4.0) + (x * (18.0 * (y * z))));
} else if (x <= -2.5e-19) {
tmp = t_2;
} else if (x <= 2.7e-36) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} 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 = (j * 27.0d0) * k
t_2 = ((b * c) + (x * ((i * (-4.0d0)) + (18.0d0 * (z * (y * t)))))) - t_1
if (x <= (-9.5d+253)) then
tmp = t * ((a * (-4.0d0)) + (x * (18.0d0 * (y * z))))
else if (x <= (-2.5d-19)) then
tmp = t_2
else if (x <= 2.7d-36) then
tmp = ((b * c) + ((-4.0d0) * (t * a))) - t_1
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 = (j * 27.0) * k;
double t_2 = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - t_1;
double tmp;
if (x <= -9.5e+253) {
tmp = t * ((a * -4.0) + (x * (18.0 * (y * z))));
} else if (x <= -2.5e-19) {
tmp = t_2;
} else if (x <= 2.7e-36) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} 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 = (j * 27.0) * k t_2 = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - t_1 tmp = 0 if x <= -9.5e+253: tmp = t * ((a * -4.0) + (x * (18.0 * (y * z)))) elif x <= -2.5e-19: tmp = t_2 elif x <= 2.7e-36: tmp = ((b * c) + (-4.0 * (t * a))) - t_1 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(Float64(j * 27.0) * k) t_2 = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(i * -4.0) + Float64(18.0 * Float64(z * Float64(y * t)))))) - t_1) tmp = 0.0 if (x <= -9.5e+253) tmp = Float64(t * Float64(Float64(a * -4.0) + Float64(x * Float64(18.0 * Float64(y * z))))); elseif (x <= -2.5e-19) tmp = t_2; elseif (x <= 2.7e-36) tmp = Float64(Float64(Float64(b * c) + Float64(-4.0 * Float64(t * a))) - t_1); 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 = (j * 27.0) * k;
t_2 = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - t_1;
tmp = 0.0;
if (x <= -9.5e+253)
tmp = t * ((a * -4.0) + (x * (18.0 * (y * z))));
elseif (x <= -2.5e-19)
tmp = t_2;
elseif (x <= 2.7e-36)
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
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[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(18.0 * N[(z * N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]}, If[LessEqual[x, -9.5e+253], N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.5e-19], t$95$2, If[LessEqual[x, 2.7e-36], N[(N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $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 := \left(j \cdot 27\right) \cdot k\\
t_2 := \left(b \cdot c + x \cdot \left(i \cdot -4 + 18 \cdot \left(z \cdot \left(y \cdot t\right)\right)\right)\right) - t\_1\\
\mathbf{if}\;x \leq -9.5 \cdot 10^{+253}:\\
\;\;\;\;t \cdot \left(a \cdot -4 + x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\
\mathbf{elif}\;x \leq -2.5 \cdot 10^{-19}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 2.7 \cdot 10^{-36}:\\
\;\;\;\;\left(b \cdot c + -4 \cdot \left(t \cdot a\right)\right) - t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -9.50000000000000005e253Initial program 51.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
Simplified51.2%
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-*.f6490.8%
Simplified90.8%
if -9.50000000000000005e253 < x < -2.5000000000000002e-19 or 2.70000000000000007e-36 < x Initial program 76.5%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Simplified84.3%
if -2.5000000000000002e-19 < x < 2.70000000000000007e-36Initial program 97.3%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6485.8%
Simplified85.8%
Final simplification85.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 (* -4.0 (* x i))))
(if (<= k -1.7e-93)
(* j (* k -27.0))
(if (<= k -2.35e-271)
t_1
(if (<= k 4.3e-270)
(* b c)
(if (<= k 4.3e-138)
(* -4.0 (* t a))
(if (<= k 3.7e+55)
(* b c)
(if (<= k 4.5e+84) t_1 (* k (* j -27.0))))))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = -4.0 * (x * i);
double tmp;
if (k <= -1.7e-93) {
tmp = j * (k * -27.0);
} else if (k <= -2.35e-271) {
tmp = t_1;
} else if (k <= 4.3e-270) {
tmp = b * c;
} else if (k <= 4.3e-138) {
tmp = -4.0 * (t * a);
} else if (k <= 3.7e+55) {
tmp = b * c;
} else if (k <= 4.5e+84) {
tmp = t_1;
} else {
tmp = k * (j * -27.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) :: t_1
real(8) :: tmp
t_1 = (-4.0d0) * (x * i)
if (k <= (-1.7d-93)) then
tmp = j * (k * (-27.0d0))
else if (k <= (-2.35d-271)) then
tmp = t_1
else if (k <= 4.3d-270) then
tmp = b * c
else if (k <= 4.3d-138) then
tmp = (-4.0d0) * (t * a)
else if (k <= 3.7d+55) then
tmp = b * c
else if (k <= 4.5d+84) then
tmp = t_1
else
tmp = k * (j * (-27.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 t_1 = -4.0 * (x * i);
double tmp;
if (k <= -1.7e-93) {
tmp = j * (k * -27.0);
} else if (k <= -2.35e-271) {
tmp = t_1;
} else if (k <= 4.3e-270) {
tmp = b * c;
} else if (k <= 4.3e-138) {
tmp = -4.0 * (t * a);
} else if (k <= 3.7e+55) {
tmp = b * c;
} else if (k <= 4.5e+84) {
tmp = t_1;
} else {
tmp = k * (j * -27.0);
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): t_1 = -4.0 * (x * i) tmp = 0 if k <= -1.7e-93: tmp = j * (k * -27.0) elif k <= -2.35e-271: tmp = t_1 elif k <= 4.3e-270: tmp = b * c elif k <= 4.3e-138: tmp = -4.0 * (t * a) elif k <= 3.7e+55: tmp = b * c elif k <= 4.5e+84: tmp = t_1 else: tmp = k * (j * -27.0) return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(-4.0 * Float64(x * i)) tmp = 0.0 if (k <= -1.7e-93) tmp = Float64(j * Float64(k * -27.0)); elseif (k <= -2.35e-271) tmp = t_1; elseif (k <= 4.3e-270) tmp = Float64(b * c); elseif (k <= 4.3e-138) tmp = Float64(-4.0 * Float64(t * a)); elseif (k <= 3.7e+55) tmp = Float64(b * c); elseif (k <= 4.5e+84) tmp = t_1; else tmp = Float64(k * Float64(j * -27.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)
t_1 = -4.0 * (x * i);
tmp = 0.0;
if (k <= -1.7e-93)
tmp = j * (k * -27.0);
elseif (k <= -2.35e-271)
tmp = t_1;
elseif (k <= 4.3e-270)
tmp = b * c;
elseif (k <= 4.3e-138)
tmp = -4.0 * (t * a);
elseif (k <= 3.7e+55)
tmp = b * c;
elseif (k <= 4.5e+84)
tmp = t_1;
else
tmp = k * (j * -27.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_] := Block[{t$95$1 = N[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -1.7e-93], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -2.35e-271], t$95$1, If[LessEqual[k, 4.3e-270], N[(b * c), $MachinePrecision], If[LessEqual[k, 4.3e-138], N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3.7e+55], N[(b * c), $MachinePrecision], If[LessEqual[k, 4.5e+84], t$95$1, N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
t_1 := -4 \cdot \left(x \cdot i\right)\\
\mathbf{if}\;k \leq -1.7 \cdot 10^{-93}:\\
\;\;\;\;j \cdot \left(k \cdot -27\right)\\
\mathbf{elif}\;k \leq -2.35 \cdot 10^{-271}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 4.3 \cdot 10^{-270}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 4.3 \cdot 10^{-138}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right)\\
\mathbf{elif}\;k \leq 3.7 \cdot 10^{+55}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 4.5 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;k \cdot \left(j \cdot -27\right)\\
\end{array}
\end{array}
if k < -1.70000000000000001e-93Initial program 80.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
Simplified80.8%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6436.0%
Simplified36.0%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6435.9%
Applied egg-rr35.9%
if -1.70000000000000001e-93 < k < -2.35000000000000002e-271 or 3.7000000000000002e55 < k < 4.4999999999999997e84Initial program 92.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
Simplified92.5%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6432.9%
Simplified32.9%
if -2.35000000000000002e-271 < k < 4.3000000000000002e-270 or 4.3e-138 < k < 3.7000000000000002e55Initial program 82.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
Simplified82.9%
Taylor expanded in b around inf
*-lowering-*.f6436.8%
Simplified36.8%
if 4.3000000000000002e-270 < k < 4.3e-138Initial program 96.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
Simplified92.5%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6443.9%
Simplified43.9%
if 4.4999999999999997e84 < k Initial program 79.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
Simplified79.6%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6454.5%
Simplified54.5%
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6454.7%
Applied egg-rr54.7%
Final simplification39.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 (* -4.0 (* x i))) (t_2 (* j (* k -27.0))))
(if (<= k -6.8e-94)
t_2
(if (<= k -2.15e-271)
t_1
(if (<= k 1.12e-269)
(* b c)
(if (<= k 2.65e-135)
(* -4.0 (* t a))
(if (<= k 3.8e+55) (* b c) (if (<= k 2.3e+84) t_1 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 = -4.0 * (x * i);
double t_2 = j * (k * -27.0);
double tmp;
if (k <= -6.8e-94) {
tmp = t_2;
} else if (k <= -2.15e-271) {
tmp = t_1;
} else if (k <= 1.12e-269) {
tmp = b * c;
} else if (k <= 2.65e-135) {
tmp = -4.0 * (t * a);
} else if (k <= 3.8e+55) {
tmp = b * c;
} else if (k <= 2.3e+84) {
tmp = t_1;
} 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 = (-4.0d0) * (x * i)
t_2 = j * (k * (-27.0d0))
if (k <= (-6.8d-94)) then
tmp = t_2
else if (k <= (-2.15d-271)) then
tmp = t_1
else if (k <= 1.12d-269) then
tmp = b * c
else if (k <= 2.65d-135) then
tmp = (-4.0d0) * (t * a)
else if (k <= 3.8d+55) then
tmp = b * c
else if (k <= 2.3d+84) then
tmp = t_1
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 = -4.0 * (x * i);
double t_2 = j * (k * -27.0);
double tmp;
if (k <= -6.8e-94) {
tmp = t_2;
} else if (k <= -2.15e-271) {
tmp = t_1;
} else if (k <= 1.12e-269) {
tmp = b * c;
} else if (k <= 2.65e-135) {
tmp = -4.0 * (t * a);
} else if (k <= 3.8e+55) {
tmp = b * c;
} else if (k <= 2.3e+84) {
tmp = t_1;
} 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 = -4.0 * (x * i) t_2 = j * (k * -27.0) tmp = 0 if k <= -6.8e-94: tmp = t_2 elif k <= -2.15e-271: tmp = t_1 elif k <= 1.12e-269: tmp = b * c elif k <= 2.65e-135: tmp = -4.0 * (t * a) elif k <= 3.8e+55: tmp = b * c elif k <= 2.3e+84: tmp = t_1 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(-4.0 * Float64(x * i)) t_2 = Float64(j * Float64(k * -27.0)) tmp = 0.0 if (k <= -6.8e-94) tmp = t_2; elseif (k <= -2.15e-271) tmp = t_1; elseif (k <= 1.12e-269) tmp = Float64(b * c); elseif (k <= 2.65e-135) tmp = Float64(-4.0 * Float64(t * a)); elseif (k <= 3.8e+55) tmp = Float64(b * c); elseif (k <= 2.3e+84) tmp = t_1; 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 = -4.0 * (x * i);
t_2 = j * (k * -27.0);
tmp = 0.0;
if (k <= -6.8e-94)
tmp = t_2;
elseif (k <= -2.15e-271)
tmp = t_1;
elseif (k <= 1.12e-269)
tmp = b * c;
elseif (k <= 2.65e-135)
tmp = -4.0 * (t * a);
elseif (k <= 3.8e+55)
tmp = b * c;
elseif (k <= 2.3e+84)
tmp = t_1;
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[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -6.8e-94], t$95$2, If[LessEqual[k, -2.15e-271], t$95$1, If[LessEqual[k, 1.12e-269], N[(b * c), $MachinePrecision], If[LessEqual[k, 2.65e-135], N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3.8e+55], N[(b * c), $MachinePrecision], If[LessEqual[k, 2.3e+84], t$95$1, 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 := -4 \cdot \left(x \cdot i\right)\\
t_2 := j \cdot \left(k \cdot -27\right)\\
\mathbf{if}\;k \leq -6.8 \cdot 10^{-94}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;k \leq -2.15 \cdot 10^{-271}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 1.12 \cdot 10^{-269}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 2.65 \cdot 10^{-135}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right)\\
\mathbf{elif}\;k \leq 3.8 \cdot 10^{+55}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 2.3 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if k < -6.7999999999999996e-94 or 2.2999999999999999e84 < k Initial program 80.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
Simplified80.3%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6443.2%
Simplified43.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6443.2%
Applied egg-rr43.2%
if -6.7999999999999996e-94 < k < -2.15e-271 or 3.8e55 < k < 2.2999999999999999e84Initial program 92.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
Simplified92.5%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6432.9%
Simplified32.9%
if -2.15e-271 < k < 1.12e-269 or 2.65e-135 < k < 3.8e55Initial program 82.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
Simplified82.9%
Taylor expanded in b around inf
*-lowering-*.f6436.8%
Simplified36.8%
if 1.12e-269 < k < 2.65e-135Initial program 96.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
Simplified92.5%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6443.9%
Simplified43.9%
Final simplification39.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 (* -4.0 (* x i))) (t_2 (* -27.0 (* j k))))
(if (<= k -3.2e-100)
t_2
(if (<= k -1.9e-270)
t_1
(if (<= k 3.3e-270)
(* b c)
(if (<= k 2.9e-135)
(* -4.0 (* t a))
(if (<= k 3.8e+55) (* b c) (if (<= k 3.1e+84) t_1 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 = -4.0 * (x * i);
double t_2 = -27.0 * (j * k);
double tmp;
if (k <= -3.2e-100) {
tmp = t_2;
} else if (k <= -1.9e-270) {
tmp = t_1;
} else if (k <= 3.3e-270) {
tmp = b * c;
} else if (k <= 2.9e-135) {
tmp = -4.0 * (t * a);
} else if (k <= 3.8e+55) {
tmp = b * c;
} else if (k <= 3.1e+84) {
tmp = t_1;
} 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 = (-4.0d0) * (x * i)
t_2 = (-27.0d0) * (j * k)
if (k <= (-3.2d-100)) then
tmp = t_2
else if (k <= (-1.9d-270)) then
tmp = t_1
else if (k <= 3.3d-270) then
tmp = b * c
else if (k <= 2.9d-135) then
tmp = (-4.0d0) * (t * a)
else if (k <= 3.8d+55) then
tmp = b * c
else if (k <= 3.1d+84) then
tmp = t_1
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 = -4.0 * (x * i);
double t_2 = -27.0 * (j * k);
double tmp;
if (k <= -3.2e-100) {
tmp = t_2;
} else if (k <= -1.9e-270) {
tmp = t_1;
} else if (k <= 3.3e-270) {
tmp = b * c;
} else if (k <= 2.9e-135) {
tmp = -4.0 * (t * a);
} else if (k <= 3.8e+55) {
tmp = b * c;
} else if (k <= 3.1e+84) {
tmp = t_1;
} 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 = -4.0 * (x * i) t_2 = -27.0 * (j * k) tmp = 0 if k <= -3.2e-100: tmp = t_2 elif k <= -1.9e-270: tmp = t_1 elif k <= 3.3e-270: tmp = b * c elif k <= 2.9e-135: tmp = -4.0 * (t * a) elif k <= 3.8e+55: tmp = b * c elif k <= 3.1e+84: tmp = t_1 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(-4.0 * Float64(x * i)) t_2 = Float64(-27.0 * Float64(j * k)) tmp = 0.0 if (k <= -3.2e-100) tmp = t_2; elseif (k <= -1.9e-270) tmp = t_1; elseif (k <= 3.3e-270) tmp = Float64(b * c); elseif (k <= 2.9e-135) tmp = Float64(-4.0 * Float64(t * a)); elseif (k <= 3.8e+55) tmp = Float64(b * c); elseif (k <= 3.1e+84) tmp = t_1; 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 = -4.0 * (x * i);
t_2 = -27.0 * (j * k);
tmp = 0.0;
if (k <= -3.2e-100)
tmp = t_2;
elseif (k <= -1.9e-270)
tmp = t_1;
elseif (k <= 3.3e-270)
tmp = b * c;
elseif (k <= 2.9e-135)
tmp = -4.0 * (t * a);
elseif (k <= 3.8e+55)
tmp = b * c;
elseif (k <= 3.1e+84)
tmp = t_1;
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[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -3.2e-100], t$95$2, If[LessEqual[k, -1.9e-270], t$95$1, If[LessEqual[k, 3.3e-270], N[(b * c), $MachinePrecision], If[LessEqual[k, 2.9e-135], N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3.8e+55], N[(b * c), $MachinePrecision], If[LessEqual[k, 3.1e+84], t$95$1, 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 := -4 \cdot \left(x \cdot i\right)\\
t_2 := -27 \cdot \left(j \cdot k\right)\\
\mathbf{if}\;k \leq -3.2 \cdot 10^{-100}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;k \leq -1.9 \cdot 10^{-270}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 3.3 \cdot 10^{-270}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 2.9 \cdot 10^{-135}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right)\\
\mathbf{elif}\;k \leq 3.8 \cdot 10^{+55}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 3.1 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if k < -3.20000000000000017e-100 or 3.10000000000000003e84 < k Initial program 80.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
Simplified80.3%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6443.2%
Simplified43.2%
if -3.20000000000000017e-100 < k < -1.90000000000000021e-270 or 3.8e55 < k < 3.10000000000000003e84Initial program 92.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
Simplified92.5%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6432.9%
Simplified32.9%
if -1.90000000000000021e-270 < k < 3.30000000000000018e-270 or 2.9000000000000002e-135 < k < 3.8e55Initial program 82.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
Simplified82.9%
Taylor expanded in b around inf
*-lowering-*.f6436.8%
Simplified36.8%
if 3.30000000000000018e-270 < k < 2.9000000000000002e-135Initial program 96.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
Simplified92.5%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6443.9%
Simplified43.9%
Final simplification39.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 (* (* j 27.0) k)))
(if (<= x -1.9e+191)
(* c (+ b (/ (* t (+ (* a -4.0) (* 18.0 (* z (* x y))))) c)))
(if (<= x -2.1e+47)
(+ (* t (+ (* (* (* x 18.0) y) z) (* a -4.0))) (* -4.0 (* x i)))
(if (<= x 3.8e-47)
(- (+ (* b c) (* -4.0 (* t a))) t_1)
(if (<= x 4.7e+168)
(- (- (* b c) (* (* x 4.0) i)) t_1)
(* x (+ (* i -4.0) (* t (* z (* 18.0 y)))))))))))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 (x <= -1.9e+191) {
tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / c));
} else if (x <= -2.1e+47) {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (-4.0 * (x * i));
} else if (x <= 3.8e-47) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} else if (x <= 4.7e+168) {
tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
} else {
tmp = x * ((i * -4.0) + (t * (z * (18.0 * y))));
}
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 (x <= (-1.9d+191)) then
tmp = c * (b + ((t * ((a * (-4.0d0)) + (18.0d0 * (z * (x * y))))) / c))
else if (x <= (-2.1d+47)) then
tmp = (t * ((((x * 18.0d0) * y) * z) + (a * (-4.0d0)))) + ((-4.0d0) * (x * i))
else if (x <= 3.8d-47) then
tmp = ((b * c) + ((-4.0d0) * (t * a))) - t_1
else if (x <= 4.7d+168) then
tmp = ((b * c) - ((x * 4.0d0) * i)) - t_1
else
tmp = x * ((i * (-4.0d0)) + (t * (z * (18.0d0 * y))))
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 (x <= -1.9e+191) {
tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / c));
} else if (x <= -2.1e+47) {
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (-4.0 * (x * i));
} else if (x <= 3.8e-47) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} else if (x <= 4.7e+168) {
tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
} else {
tmp = x * ((i * -4.0) + (t * (z * (18.0 * y))));
}
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 x <= -1.9e+191: tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / c)) elif x <= -2.1e+47: tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (-4.0 * (x * i)) elif x <= 3.8e-47: tmp = ((b * c) + (-4.0 * (t * a))) - t_1 elif x <= 4.7e+168: tmp = ((b * c) - ((x * 4.0) * i)) - t_1 else: tmp = x * ((i * -4.0) + (t * (z * (18.0 * y)))) 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 (x <= -1.9e+191) tmp = Float64(c * Float64(b + Float64(Float64(t * Float64(Float64(a * -4.0) + Float64(18.0 * Float64(z * Float64(x * y))))) / c))); elseif (x <= -2.1e+47) tmp = Float64(Float64(t * Float64(Float64(Float64(Float64(x * 18.0) * y) * z) + Float64(a * -4.0))) + Float64(-4.0 * Float64(x * i))); elseif (x <= 3.8e-47) tmp = Float64(Float64(Float64(b * c) + Float64(-4.0 * Float64(t * a))) - t_1); elseif (x <= 4.7e+168) tmp = Float64(Float64(Float64(b * c) - Float64(Float64(x * 4.0) * i)) - t_1); else tmp = Float64(x * Float64(Float64(i * -4.0) + Float64(t * Float64(z * Float64(18.0 * y))))); 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 (x <= -1.9e+191)
tmp = c * (b + ((t * ((a * -4.0) + (18.0 * (z * (x * y))))) / c));
elseif (x <= -2.1e+47)
tmp = (t * ((((x * 18.0) * y) * z) + (a * -4.0))) + (-4.0 * (x * i));
elseif (x <= 3.8e-47)
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
elseif (x <= 4.7e+168)
tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
else
tmp = x * ((i * -4.0) + (t * (z * (18.0 * y))));
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[x, -1.9e+191], N[(c * N[(b + N[(N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(18.0 * N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.1e+47], N[(N[(t * N[(N[(N[(N[(x * 18.0), $MachinePrecision] * y), $MachinePrecision] * z), $MachinePrecision] + N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.8e-47], N[(N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 4.7e+168], N[(N[(N[(b * c), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(t * N[(z * N[(18.0 * y), $MachinePrecision]), $MachinePrecision]), $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(j \cdot 27\right) \cdot k\\
\mathbf{if}\;x \leq -1.9 \cdot 10^{+191}:\\
\;\;\;\;c \cdot \left(b + \frac{t \cdot \left(a \cdot -4 + 18 \cdot \left(z \cdot \left(x \cdot y\right)\right)\right)}{c}\right)\\
\mathbf{elif}\;x \leq -2.1 \cdot 10^{+47}:\\
\;\;\;\;t \cdot \left(\left(\left(x \cdot 18\right) \cdot y\right) \cdot z + a \cdot -4\right) + -4 \cdot \left(x \cdot i\right)\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{-47}:\\
\;\;\;\;\left(b \cdot c + -4 \cdot \left(t \cdot a\right)\right) - t\_1\\
\mathbf{elif}\;x \leq 4.7 \cdot 10^{+168}:\\
\;\;\;\;\left(b \cdot c - \left(x \cdot 4\right) \cdot i\right) - t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(i \cdot -4 + t \cdot \left(z \cdot \left(18 \cdot y\right)\right)\right)\\
\end{array}
\end{array}
if x < -1.8999999999999999e191Initial program 51.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
Simplified51.1%
Taylor expanded in b around inf
*-lowering-*.f6468.0%
Simplified68.0%
Taylor expanded in c around inf
Simplified79.0%
if -1.8999999999999999e191 < x < -2.1e47Initial program 73.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
Simplified73.4%
Taylor expanded in x around inf
*-lowering-*.f64N/A
*-lowering-*.f6463.9%
Simplified63.9%
if -2.1e47 < x < 3.80000000000000015e-47Initial program 96.6%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6483.9%
Simplified83.9%
if 3.80000000000000015e-47 < x < 4.69999999999999961e168Initial program 79.8%
Taylor expanded in t around 0
*-lowering-*.f6479.2%
Simplified79.2%
if 4.69999999999999961e168 < x Initial program 80.7%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6488.8%
Applied egg-rr88.8%
Taylor expanded in y around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6472.5%
Simplified72.5%
Taylor expanded in x around inf
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6491.8%
Simplified91.8%
Final simplification81.0%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1
(-
(* t (+ (* a -4.0) (* x (* 18.0 (* y z)))))
(+ (* (* x 4.0) i) (* j (* 27.0 k))))))
(if (<= t -2.8e-93)
t_1
(if (<= t 1.26e-84)
(-
(+ (* b c) (* x (+ (* i -4.0) (* 18.0 (* z (* y t))))))
(* (* 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))))) - (((x * 4.0) * i) + (j * (27.0 * k)));
double tmp;
if (t <= -2.8e-93) {
tmp = t_1;
} else if (t <= 1.26e-84) {
tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - ((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))))) - (((x * 4.0d0) * i) + (j * (27.0d0 * k)))
if (t <= (-2.8d-93)) then
tmp = t_1
else if (t <= 1.26d-84) then
tmp = ((b * c) + (x * ((i * (-4.0d0)) + (18.0d0 * (z * (y * t)))))) - ((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))))) - (((x * 4.0) * i) + (j * (27.0 * k)));
double tmp;
if (t <= -2.8e-93) {
tmp = t_1;
} else if (t <= 1.26e-84) {
tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - ((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))))) - (((x * 4.0) * i) + (j * (27.0 * k))) tmp = 0 if t <= -2.8e-93: tmp = t_1 elif t <= 1.26e-84: tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - ((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(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)))) tmp = 0.0 if (t <= -2.8e-93) tmp = t_1; elseif (t <= 1.26e-84) tmp = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(i * -4.0) + Float64(18.0 * Float64(z * Float64(y * t)))))) - 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))))) - (((x * 4.0) * i) + (j * (27.0 * k)));
tmp = 0.0;
if (t <= -2.8e-93)
tmp = t_1;
elseif (t <= 1.26e-84)
tmp = ((b * c) + (x * ((i * -4.0) + (18.0 * (z * (y * t)))))) - ((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[(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, -2.8e-93], t$95$1, If[LessEqual[t, 1.26e-84], N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(18.0 * N[(z * N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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) - \left(\left(x \cdot 4\right) \cdot i + j \cdot \left(27 \cdot k\right)\right)\\
\mathbf{if}\;t \leq -2.8 \cdot 10^{-93}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.26 \cdot 10^{-84}:\\
\;\;\;\;\left(b \cdot c + x \cdot \left(i \cdot -4 + 18 \cdot \left(z \cdot \left(y \cdot t\right)\right)\right)\right) - \left(j \cdot 27\right) \cdot k\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.79999999999999998e-93 or 1.26e-84 < t Initial program 85.9%
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
associate--l+N/A
Simplified81.3%
if -2.79999999999999998e-93 < t < 1.26e-84Initial program 83.1%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Simplified91.7%
Final simplification84.9%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(if (<= x 2.9e+34)
(+
(* t (+ (* a -4.0) (* y (* (* x 18.0) z))))
(+ (* -27.0 (* j k)) (+ (* b c) (* x (* i -4.0)))))
(-
(+ (* b c) (* x (+ (* i -4.0) (* y (* z (* 18.0 t))))))
(* (* j 27.0) k))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if (x <= 2.9e+34) {
tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else {
tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - ((j * 27.0) * k);
}
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 <= 2.9d+34) then
tmp = (t * ((a * (-4.0d0)) + (y * ((x * 18.0d0) * z)))) + (((-27.0d0) * (j * k)) + ((b * c) + (x * (i * (-4.0d0)))))
else
tmp = ((b * c) + (x * ((i * (-4.0d0)) + (y * (z * (18.0d0 * t)))))) - ((j * 27.0d0) * k)
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 <= 2.9e+34) {
tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
} else {
tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - ((j * 27.0) * k);
}
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 <= 2.9e+34: tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0)))) else: tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - ((j * 27.0) * k) return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (x <= 2.9e+34) tmp = Float64(Float64(t * Float64(Float64(a * -4.0) + Float64(y * Float64(Float64(x * 18.0) * z)))) + Float64(Float64(-27.0 * Float64(j * k)) + Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))))); else tmp = Float64(Float64(Float64(b * c) + Float64(x * Float64(Float64(i * -4.0) + Float64(y * Float64(z * Float64(18.0 * t)))))) - Float64(Float64(j * 27.0) * k)); 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 <= 2.9e+34)
tmp = (t * ((a * -4.0) + (y * ((x * 18.0) * z)))) + ((-27.0 * (j * k)) + ((b * c) + (x * (i * -4.0))));
else
tmp = ((b * c) + (x * ((i * -4.0) + (y * (z * (18.0 * t)))))) - ((j * 27.0) * k);
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, 2.9e+34], N[(N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(y * N[(N[(x * 18.0), $MachinePrecision] * z), $MachinePrecision]), $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], N[(N[(N[(b * c), $MachinePrecision] + N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(y * N[(z * N[(18.0 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq 2.9 \cdot 10^{+34}:\\
\;\;\;\;t \cdot \left(a \cdot -4 + y \cdot \left(\left(x \cdot 18\right) \cdot z\right)\right) + \left(-27 \cdot \left(j \cdot k\right) + \left(b \cdot c + x \cdot \left(i \cdot -4\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot c + x \cdot \left(i \cdot -4 + y \cdot \left(z \cdot \left(18 \cdot t\right)\right)\right)\right) - \left(j \cdot 27\right) \cdot k\\
\end{array}
\end{array}
if x < 2.9000000000000001e34Initial program 88.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
Simplified87.6%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6488.5%
Applied egg-rr88.5%
if 2.9000000000000001e34 < x Initial program 75.3%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6487.4%
Applied egg-rr87.4%
Taylor expanded in a around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
associate-+l+N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Simplified92.2%
Final simplification89.5%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (* j 27.0) k))
(t_2 (* x (+ (* i -4.0) (* t (* z (* 18.0 y)))))))
(if (<= x -1.6e+47)
t_2
(if (<= x -1.3e-215)
(- (* -4.0 (* t a)) t_1)
(if (<= x 6.2e-136)
(+ (* b c) (* t (* a -4.0)))
(if (<= x 4.2e-20) (- (* b c) t_1) 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 = (j * 27.0) * k;
double t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
double tmp;
if (x <= -1.6e+47) {
tmp = t_2;
} else if (x <= -1.3e-215) {
tmp = (-4.0 * (t * a)) - t_1;
} else if (x <= 6.2e-136) {
tmp = (b * c) + (t * (a * -4.0));
} else if (x <= 4.2e-20) {
tmp = (b * c) - t_1;
} 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 = (j * 27.0d0) * k
t_2 = x * ((i * (-4.0d0)) + (t * (z * (18.0d0 * y))))
if (x <= (-1.6d+47)) then
tmp = t_2
else if (x <= (-1.3d-215)) then
tmp = ((-4.0d0) * (t * a)) - t_1
else if (x <= 6.2d-136) then
tmp = (b * c) + (t * (a * (-4.0d0)))
else if (x <= 4.2d-20) then
tmp = (b * c) - t_1
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 = (j * 27.0) * k;
double t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
double tmp;
if (x <= -1.6e+47) {
tmp = t_2;
} else if (x <= -1.3e-215) {
tmp = (-4.0 * (t * a)) - t_1;
} else if (x <= 6.2e-136) {
tmp = (b * c) + (t * (a * -4.0));
} else if (x <= 4.2e-20) {
tmp = (b * c) - t_1;
} 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 = (j * 27.0) * k t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y)))) tmp = 0 if x <= -1.6e+47: tmp = t_2 elif x <= -1.3e-215: tmp = (-4.0 * (t * a)) - t_1 elif x <= 6.2e-136: tmp = (b * c) + (t * (a * -4.0)) elif x <= 4.2e-20: tmp = (b * c) - t_1 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(Float64(j * 27.0) * k) t_2 = Float64(x * Float64(Float64(i * -4.0) + Float64(t * Float64(z * Float64(18.0 * y))))) tmp = 0.0 if (x <= -1.6e+47) tmp = t_2; elseif (x <= -1.3e-215) tmp = Float64(Float64(-4.0 * Float64(t * a)) - t_1); elseif (x <= 6.2e-136) tmp = Float64(Float64(b * c) + Float64(t * Float64(a * -4.0))); elseif (x <= 4.2e-20) tmp = Float64(Float64(b * c) - t_1); 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 = (j * 27.0) * k;
t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
tmp = 0.0;
if (x <= -1.6e+47)
tmp = t_2;
elseif (x <= -1.3e-215)
tmp = (-4.0 * (t * a)) - t_1;
elseif (x <= 6.2e-136)
tmp = (b * c) + (t * (a * -4.0));
elseif (x <= 4.2e-20)
tmp = (b * c) - t_1;
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[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(t * N[(z * N[(18.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.6e+47], t$95$2, If[LessEqual[x, -1.3e-215], N[(N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 6.2e-136], N[(N[(b * c), $MachinePrecision] + N[(t * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.2e-20], N[(N[(b * c), $MachinePrecision] - t$95$1), $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 := \left(j \cdot 27\right) \cdot k\\
t_2 := x \cdot \left(i \cdot -4 + t \cdot \left(z \cdot \left(18 \cdot y\right)\right)\right)\\
\mathbf{if}\;x \leq -1.6 \cdot 10^{+47}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.3 \cdot 10^{-215}:\\
\;\;\;\;-4 \cdot \left(t \cdot a\right) - t\_1\\
\mathbf{elif}\;x \leq 6.2 \cdot 10^{-136}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{elif}\;x \leq 4.2 \cdot 10^{-20}:\\
\;\;\;\;b \cdot c - t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.6e47 or 4.1999999999999998e-20 < x Initial program 73.1%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6483.5%
Applied egg-rr83.5%
Taylor expanded in y around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6470.6%
Simplified70.6%
Taylor expanded in x around inf
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.0%
Simplified67.0%
if -1.6e47 < x < -1.3e-215Initial program 97.8%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6460.9%
Simplified60.9%
if -1.3e-215 < x < 6.2e-136Initial program 96.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
Simplified94.1%
Taylor expanded in b around inf
*-lowering-*.f6470.2%
Simplified70.2%
Taylor expanded in x around 0
*-lowering-*.f6469.9%
Simplified69.9%
if 6.2e-136 < x < 4.1999999999999998e-20Initial program 96.2%
Taylor expanded in b around inf
*-lowering-*.f6474.9%
Simplified74.9%
Final simplification67.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 (* x (* i -4.0)))
(t_2 (* t (+ (* a -4.0) (* x (* 18.0 (* y z)))))))
(if (<= x -4.2e+253)
t_2
(if (<= x -1.1e+88)
(+ (* b c) t_1)
(if (<= x -3.1e-159)
t_2
(if (<= x 5.8e-27)
(- (* b c) (* (* j 27.0) k))
(- t_1 (* j (* 27.0 k)))))))))assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double t_1 = x * (i * -4.0);
double t_2 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
double tmp;
if (x <= -4.2e+253) {
tmp = t_2;
} else if (x <= -1.1e+88) {
tmp = (b * c) + t_1;
} else if (x <= -3.1e-159) {
tmp = t_2;
} else if (x <= 5.8e-27) {
tmp = (b * c) - ((j * 27.0) * k);
} else {
tmp = t_1 - (j * (27.0 * k));
}
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 = x * (i * (-4.0d0))
t_2 = t * ((a * (-4.0d0)) + (x * (18.0d0 * (y * z))))
if (x <= (-4.2d+253)) then
tmp = t_2
else if (x <= (-1.1d+88)) then
tmp = (b * c) + t_1
else if (x <= (-3.1d-159)) then
tmp = t_2
else if (x <= 5.8d-27) then
tmp = (b * c) - ((j * 27.0d0) * k)
else
tmp = t_1 - (j * (27.0d0 * k))
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);
double t_2 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
double tmp;
if (x <= -4.2e+253) {
tmp = t_2;
} else if (x <= -1.1e+88) {
tmp = (b * c) + t_1;
} else if (x <= -3.1e-159) {
tmp = t_2;
} else if (x <= 5.8e-27) {
tmp = (b * c) - ((j * 27.0) * k);
} else {
tmp = t_1 - (j * (27.0 * k));
}
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_2 = t * ((a * -4.0) + (x * (18.0 * (y * z)))) tmp = 0 if x <= -4.2e+253: tmp = t_2 elif x <= -1.1e+88: tmp = (b * c) + t_1 elif x <= -3.1e-159: tmp = t_2 elif x <= 5.8e-27: tmp = (b * c) - ((j * 27.0) * k) else: tmp = t_1 - (j * (27.0 * k)) return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) t_1 = Float64(x * Float64(i * -4.0)) t_2 = Float64(t * Float64(Float64(a * -4.0) + Float64(x * Float64(18.0 * Float64(y * z))))) tmp = 0.0 if (x <= -4.2e+253) tmp = t_2; elseif (x <= -1.1e+88) tmp = Float64(Float64(b * c) + t_1); elseif (x <= -3.1e-159) tmp = t_2; elseif (x <= 5.8e-27) tmp = Float64(Float64(b * c) - Float64(Float64(j * 27.0) * k)); else tmp = Float64(t_1 - Float64(j * Float64(27.0 * k))); 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_2 = t * ((a * -4.0) + (x * (18.0 * (y * z))));
tmp = 0.0;
if (x <= -4.2e+253)
tmp = t_2;
elseif (x <= -1.1e+88)
tmp = (b * c) + t_1;
elseif (x <= -3.1e-159)
tmp = t_2;
elseif (x <= 5.8e-27)
tmp = (b * c) - ((j * 27.0) * k);
else
tmp = t_1 - (j * (27.0 * k));
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[(i * -4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(a * -4.0), $MachinePrecision] + N[(x * N[(18.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4.2e+253], t$95$2, If[LessEqual[x, -1.1e+88], N[(N[(b * c), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[x, -3.1e-159], t$95$2, If[LessEqual[x, 5.8e-27], N[(N[(b * c), $MachinePrecision] - N[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision], N[(t$95$1 - N[(j * N[(27.0 * k), $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 := x \cdot \left(i \cdot -4\right)\\
t_2 := t \cdot \left(a \cdot -4 + x \cdot \left(18 \cdot \left(y \cdot z\right)\right)\right)\\
\mathbf{if}\;x \leq -4.2 \cdot 10^{+253}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.1 \cdot 10^{+88}:\\
\;\;\;\;b \cdot c + t\_1\\
\mathbf{elif}\;x \leq -3.1 \cdot 10^{-159}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 5.8 \cdot 10^{-27}:\\
\;\;\;\;b \cdot c - \left(j \cdot 27\right) \cdot k\\
\mathbf{else}:\\
\;\;\;\;t\_1 - j \cdot \left(27 \cdot k\right)\\
\end{array}
\end{array}
if x < -4.2000000000000003e253 or -1.10000000000000004e88 < x < -3.1e-159Initial program 86.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
Simplified86.3%
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-*.f6463.6%
Simplified63.6%
if -4.2000000000000003e253 < x < -1.10000000000000004e88Initial program 65.4%
Taylor expanded in t around 0
*-lowering-*.f6456.6%
Simplified56.6%
Taylor expanded in j around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6455.0%
Simplified55.0%
if -3.1e-159 < x < 5.80000000000000008e-27Initial program 96.6%
Taylor expanded in b around inf
*-lowering-*.f6464.7%
Simplified64.7%
if 5.80000000000000008e-27 < x Initial program 78.3%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6465.7%
Simplified65.7%
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6465.7%
Applied egg-rr65.7%
Final simplification63.4%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function.
(FPCore (x y z t a b c i j k)
:precision binary64
(let* ((t_1 (* (* j 27.0) k))
(t_2 (* x (+ (* i -4.0) (* t (* z (* 18.0 y)))))))
(if (<= x -4.8e+46)
t_2
(if (<= x 3.7e-47)
(- (+ (* b c) (* -4.0 (* t a))) t_1)
(if (<= x 3.2e+168) (- (- (* b c) (* (* x 4.0) i)) t_1) 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 = (j * 27.0) * k;
double t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
double tmp;
if (x <= -4.8e+46) {
tmp = t_2;
} else if (x <= 3.7e-47) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} else if (x <= 3.2e+168) {
tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
} 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 = (j * 27.0d0) * k
t_2 = x * ((i * (-4.0d0)) + (t * (z * (18.0d0 * y))))
if (x <= (-4.8d+46)) then
tmp = t_2
else if (x <= 3.7d-47) then
tmp = ((b * c) + ((-4.0d0) * (t * a))) - t_1
else if (x <= 3.2d+168) then
tmp = ((b * c) - ((x * 4.0d0) * i)) - t_1
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 = (j * 27.0) * k;
double t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
double tmp;
if (x <= -4.8e+46) {
tmp = t_2;
} else if (x <= 3.7e-47) {
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
} else if (x <= 3.2e+168) {
tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
} 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 = (j * 27.0) * k t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y)))) tmp = 0 if x <= -4.8e+46: tmp = t_2 elif x <= 3.7e-47: tmp = ((b * c) + (-4.0 * (t * a))) - t_1 elif x <= 3.2e+168: tmp = ((b * c) - ((x * 4.0) * i)) - t_1 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(Float64(j * 27.0) * k) t_2 = Float64(x * Float64(Float64(i * -4.0) + Float64(t * Float64(z * Float64(18.0 * y))))) tmp = 0.0 if (x <= -4.8e+46) tmp = t_2; elseif (x <= 3.7e-47) tmp = Float64(Float64(Float64(b * c) + Float64(-4.0 * Float64(t * a))) - t_1); elseif (x <= 3.2e+168) tmp = Float64(Float64(Float64(b * c) - Float64(Float64(x * 4.0) * i)) - t_1); 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 = (j * 27.0) * k;
t_2 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
tmp = 0.0;
if (x <= -4.8e+46)
tmp = t_2;
elseif (x <= 3.7e-47)
tmp = ((b * c) + (-4.0 * (t * a))) - t_1;
elseif (x <= 3.2e+168)
tmp = ((b * c) - ((x * 4.0) * i)) - t_1;
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[(N[(j * 27.0), $MachinePrecision] * k), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(t * N[(z * N[(18.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4.8e+46], t$95$2, If[LessEqual[x, 3.7e-47], N[(N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[x, 3.2e+168], N[(N[(N[(b * c), $MachinePrecision] - N[(N[(x * 4.0), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - t$95$1), $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 := \left(j \cdot 27\right) \cdot k\\
t_2 := x \cdot \left(i \cdot -4 + t \cdot \left(z \cdot \left(18 \cdot y\right)\right)\right)\\
\mathbf{if}\;x \leq -4.8 \cdot 10^{+46}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 3.7 \cdot 10^{-47}:\\
\;\;\;\;\left(b \cdot c + -4 \cdot \left(t \cdot a\right)\right) - t\_1\\
\mathbf{elif}\;x \leq 3.2 \cdot 10^{+168}:\\
\;\;\;\;\left(b \cdot c - \left(x \cdot 4\right) \cdot i\right) - t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -4.80000000000000017e46 or 3.2000000000000001e168 < x Initial program 71.9%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6482.3%
Applied egg-rr82.3%
Taylor expanded in y around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6470.6%
Simplified70.6%
Taylor expanded in x around inf
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6472.8%
Simplified72.8%
if -4.80000000000000017e46 < x < 3.7e-47Initial program 96.6%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6483.9%
Simplified83.9%
if 3.7e-47 < x < 3.2000000000000001e168Initial program 79.8%
Taylor expanded in t around 0
*-lowering-*.f6479.2%
Simplified79.2%
Final simplification79.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 (* -4.0 (* x i))) (t_2 (* -27.0 (* j k))))
(if (<= k -6.4e-97)
t_2
(if (<= k -1.65e-270)
t_1
(if (<= k 3.8e+55) (* b c) (if (<= k 1.2e+84) t_1 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 = -4.0 * (x * i);
double t_2 = -27.0 * (j * k);
double tmp;
if (k <= -6.4e-97) {
tmp = t_2;
} else if (k <= -1.65e-270) {
tmp = t_1;
} else if (k <= 3.8e+55) {
tmp = b * c;
} else if (k <= 1.2e+84) {
tmp = t_1;
} 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 = (-4.0d0) * (x * i)
t_2 = (-27.0d0) * (j * k)
if (k <= (-6.4d-97)) then
tmp = t_2
else if (k <= (-1.65d-270)) then
tmp = t_1
else if (k <= 3.8d+55) then
tmp = b * c
else if (k <= 1.2d+84) then
tmp = t_1
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 = -4.0 * (x * i);
double t_2 = -27.0 * (j * k);
double tmp;
if (k <= -6.4e-97) {
tmp = t_2;
} else if (k <= -1.65e-270) {
tmp = t_1;
} else if (k <= 3.8e+55) {
tmp = b * c;
} else if (k <= 1.2e+84) {
tmp = t_1;
} 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 = -4.0 * (x * i) t_2 = -27.0 * (j * k) tmp = 0 if k <= -6.4e-97: tmp = t_2 elif k <= -1.65e-270: tmp = t_1 elif k <= 3.8e+55: tmp = b * c elif k <= 1.2e+84: tmp = t_1 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(-4.0 * Float64(x * i)) t_2 = Float64(-27.0 * Float64(j * k)) tmp = 0.0 if (k <= -6.4e-97) tmp = t_2; elseif (k <= -1.65e-270) tmp = t_1; elseif (k <= 3.8e+55) tmp = Float64(b * c); elseif (k <= 1.2e+84) tmp = t_1; 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 = -4.0 * (x * i);
t_2 = -27.0 * (j * k);
tmp = 0.0;
if (k <= -6.4e-97)
tmp = t_2;
elseif (k <= -1.65e-270)
tmp = t_1;
elseif (k <= 3.8e+55)
tmp = b * c;
elseif (k <= 1.2e+84)
tmp = t_1;
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[(-4.0 * N[(x * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -6.4e-97], t$95$2, If[LessEqual[k, -1.65e-270], t$95$1, If[LessEqual[k, 3.8e+55], N[(b * c), $MachinePrecision], If[LessEqual[k, 1.2e+84], t$95$1, 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 := -4 \cdot \left(x \cdot i\right)\\
t_2 := -27 \cdot \left(j \cdot k\right)\\
\mathbf{if}\;k \leq -6.4 \cdot 10^{-97}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;k \leq -1.65 \cdot 10^{-270}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 3.8 \cdot 10^{+55}:\\
\;\;\;\;b \cdot c\\
\mathbf{elif}\;k \leq 1.2 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if k < -6.39999999999999961e-97 or 1.2e84 < k Initial program 80.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
Simplified80.3%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6443.2%
Simplified43.2%
if -6.39999999999999961e-97 < k < -1.65000000000000009e-270 or 3.8e55 < k < 1.2e84Initial program 92.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
Simplified92.5%
Taylor expanded in i around inf
*-lowering-*.f64N/A
*-lowering-*.f6432.9%
Simplified32.9%
if -1.65000000000000009e-270 < k < 3.8e55Initial program 87.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
Simplified86.0%
Taylor expanded in b around inf
*-lowering-*.f6432.8%
Simplified32.8%
Final simplification37.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 (* z (* 18.0 y)))))))
(if (<= x -2.8e+47)
t_1
(if (<= x 1.4e-14)
(- (+ (* b c) (* -4.0 (* t a))) (* (* 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 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
double tmp;
if (x <= -2.8e+47) {
tmp = t_1;
} else if (x <= 1.4e-14) {
tmp = ((b * c) + (-4.0 * (t * a))) - ((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 = x * ((i * (-4.0d0)) + (t * (z * (18.0d0 * y))))
if (x <= (-2.8d+47)) then
tmp = t_1
else if (x <= 1.4d-14) then
tmp = ((b * c) + ((-4.0d0) * (t * a))) - ((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 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
double tmp;
if (x <= -2.8e+47) {
tmp = t_1;
} else if (x <= 1.4e-14) {
tmp = ((b * c) + (-4.0 * (t * a))) - ((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 = x * ((i * -4.0) + (t * (z * (18.0 * y)))) tmp = 0 if x <= -2.8e+47: tmp = t_1 elif x <= 1.4e-14: tmp = ((b * c) + (-4.0 * (t * a))) - ((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(x * Float64(Float64(i * -4.0) + Float64(t * Float64(z * Float64(18.0 * y))))) tmp = 0.0 if (x <= -2.8e+47) tmp = t_1; elseif (x <= 1.4e-14) tmp = Float64(Float64(Float64(b * c) + Float64(-4.0 * Float64(t * a))) - 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 = x * ((i * -4.0) + (t * (z * (18.0 * y))));
tmp = 0.0;
if (x <= -2.8e+47)
tmp = t_1;
elseif (x <= 1.4e-14)
tmp = ((b * c) + (-4.0 * (t * a))) - ((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[(x * N[(N[(i * -4.0), $MachinePrecision] + N[(t * N[(z * N[(18.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.8e+47], t$95$1, If[LessEqual[x, 1.4e-14], N[(N[(N[(b * c), $MachinePrecision] + N[(-4.0 * N[(t * a), $MachinePrecision]), $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 := x \cdot \left(i \cdot -4 + t \cdot \left(z \cdot \left(18 \cdot y\right)\right)\right)\\
\mathbf{if}\;x \leq -2.8 \cdot 10^{+47}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\left(b \cdot c + -4 \cdot \left(t \cdot a\right)\right) - \left(j \cdot 27\right) \cdot k\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.79999999999999988e47 or 1.4e-14 < x Initial program 73.1%
+-commutativeN/A
associate-+r-N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6483.5%
Applied egg-rr83.5%
Taylor expanded in y around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6470.6%
Simplified70.6%
Taylor expanded in x around inf
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.0%
Simplified67.0%
if -2.79999999999999988e47 < x < 1.4e-14Initial program 96.8%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6484.8%
Simplified84.8%
Final simplification75.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 (+ (* b c) (* x (* i -4.0)))))
(if (<= x -6e+188)
(* t (* x (* z (* 18.0 y))))
(if (<= x -4.8e+88)
t_1
(if (<= x 4.4e-47) (+ (* b c) (* 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 = (b * c) + (x * (i * -4.0));
double tmp;
if (x <= -6e+188) {
tmp = t * (x * (z * (18.0 * y)));
} else if (x <= -4.8e+88) {
tmp = t_1;
} else if (x <= 4.4e-47) {
tmp = (b * c) + (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 = (b * c) + (x * (i * (-4.0d0)))
if (x <= (-6d+188)) then
tmp = t * (x * (z * (18.0d0 * y)))
else if (x <= (-4.8d+88)) then
tmp = t_1
else if (x <= 4.4d-47) then
tmp = (b * c) + (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 = (b * c) + (x * (i * -4.0));
double tmp;
if (x <= -6e+188) {
tmp = t * (x * (z * (18.0 * y)));
} else if (x <= -4.8e+88) {
tmp = t_1;
} else if (x <= 4.4e-47) {
tmp = (b * c) + (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 = (b * c) + (x * (i * -4.0)) tmp = 0 if x <= -6e+188: tmp = t * (x * (z * (18.0 * y))) elif x <= -4.8e+88: tmp = t_1 elif x <= 4.4e-47: tmp = (b * c) + (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(b * c) + Float64(x * Float64(i * -4.0))) tmp = 0.0 if (x <= -6e+188) tmp = Float64(t * Float64(x * Float64(z * Float64(18.0 * y)))); elseif (x <= -4.8e+88) tmp = t_1; elseif (x <= 4.4e-47) tmp = Float64(Float64(b * c) + 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 = (b * c) + (x * (i * -4.0));
tmp = 0.0;
if (x <= -6e+188)
tmp = t * (x * (z * (18.0 * y)));
elseif (x <= -4.8e+88)
tmp = t_1;
elseif (x <= 4.4e-47)
tmp = (b * c) + (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[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -6e+188], N[(t * N[(x * N[(z * N[(18.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4.8e+88], t$95$1, If[LessEqual[x, 4.4e-47], N[(N[(b * c), $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 := b \cdot c + x \cdot \left(i \cdot -4\right)\\
\mathbf{if}\;x \leq -6 \cdot 10^{+188}:\\
\;\;\;\;t \cdot \left(x \cdot \left(z \cdot \left(18 \cdot y\right)\right)\right)\\
\mathbf{elif}\;x \leq -4.8 \cdot 10^{+88}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.4 \cdot 10^{-47}:\\
\;\;\;\;b \cdot c + t \cdot \left(a \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -6.0000000000000001e188Initial program 53.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
Simplified53.7%
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-*.f6469.2%
Simplified69.2%
Taylor expanded in a around 0
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6461.8%
Simplified61.8%
if -6.0000000000000001e188 < x < -4.7999999999999998e88 or 4.40000000000000037e-47 < x Initial program 77.5%
Taylor expanded in t around 0
*-lowering-*.f6471.6%
Simplified71.6%
Taylor expanded in j around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6459.9%
Simplified59.9%
if -4.7999999999999998e88 < x < 4.40000000000000037e-47Initial program 95.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
Simplified94.6%
Taylor expanded in b around inf
*-lowering-*.f6467.2%
Simplified67.2%
Taylor expanded in x around 0
*-lowering-*.f6455.4%
Simplified55.4%
Final simplification57.7%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. (FPCore (x y z t a b c i j k) :precision binary64 (if (<= k -3.8e-88) (* j (* k -27.0)) (if (<= k 3e+215) (+ (* b c) (* x (* i -4.0))) (* k (* j -27.0)))))
assert(x < y && y < z && z < t && t < a && a < b && b < c && c < i && i < j && j < k);
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k) {
double tmp;
if (k <= -3.8e-88) {
tmp = j * (k * -27.0);
} else if (k <= 3e+215) {
tmp = (b * c) + (x * (i * -4.0));
} else {
tmp = k * (j * -27.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 (k <= (-3.8d-88)) then
tmp = j * (k * (-27.0d0))
else if (k <= 3d+215) then
tmp = (b * c) + (x * (i * (-4.0d0)))
else
tmp = k * (j * (-27.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 (k <= -3.8e-88) {
tmp = j * (k * -27.0);
} else if (k <= 3e+215) {
tmp = (b * c) + (x * (i * -4.0));
} else {
tmp = k * (j * -27.0);
}
return tmp;
}
[x, y, z, t, a, b, c, i, j, k] = sort([x, y, z, t, a, b, c, i, j, k]) def code(x, y, z, t, a, b, c, i, j, k): tmp = 0 if k <= -3.8e-88: tmp = j * (k * -27.0) elif k <= 3e+215: tmp = (b * c) + (x * (i * -4.0)) else: tmp = k * (j * -27.0) return tmp
x, y, z, t, a, b, c, i, j, k = sort([x, y, z, t, a, b, c, i, j, k]) function code(x, y, z, t, a, b, c, i, j, k) tmp = 0.0 if (k <= -3.8e-88) tmp = Float64(j * Float64(k * -27.0)); elseif (k <= 3e+215) tmp = Float64(Float64(b * c) + Float64(x * Float64(i * -4.0))); else tmp = Float64(k * Float64(j * -27.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 (k <= -3.8e-88)
tmp = j * (k * -27.0);
elseif (k <= 3e+215)
tmp = (b * c) + (x * (i * -4.0));
else
tmp = k * (j * -27.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[k, -3.8e-88], N[(j * N[(k * -27.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3e+215], N[(N[(b * c), $MachinePrecision] + N[(x * N[(i * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(k * N[(j * -27.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t, a, b, c, i, j, k] = \mathsf{sort}([x, y, z, t, a, b, c, i, j, k])\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq -3.8 \cdot 10^{-88}:\\
\;\;\;\;j \cdot \left(k \cdot -27\right)\\
\mathbf{elif}\;k \leq 3 \cdot 10^{+215}:\\
\;\;\;\;b \cdot c + x \cdot \left(i \cdot -4\right)\\
\mathbf{else}:\\
\;\;\;\;k \cdot \left(j \cdot -27\right)\\
\end{array}
\end{array}
if k < -3.80000000000000011e-88Initial program 80.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
Simplified80.3%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6435.6%
Simplified35.6%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6435.6%
Applied egg-rr35.6%
if -3.80000000000000011e-88 < k < 2.9999999999999999e215Initial program 88.9%
Taylor expanded in t around 0
*-lowering-*.f6457.7%
Simplified57.7%
Taylor expanded in j around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.2%
Simplified48.2%
if 2.9999999999999999e215 < k Initial program 70.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
Simplified70.1%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6475.6%
Simplified75.6%
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6475.7%
Applied egg-rr75.7%
Final simplification46.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 (* -27.0 (* j k)))) (if (<= k -2.8e-153) t_1 (if (<= k 2.1e+63) (* 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 (k <= -2.8e-153) {
tmp = t_1;
} else if (k <= 2.1e+63) {
tmp = b * c;
} 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 = (-27.0d0) * (j * k)
if (k <= (-2.8d-153)) then
tmp = t_1
else if (k <= 2.1d+63) then
tmp = b * c
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 = -27.0 * (j * k);
double tmp;
if (k <= -2.8e-153) {
tmp = t_1;
} else if (k <= 2.1e+63) {
tmp = b * c;
} 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 = -27.0 * (j * k) tmp = 0 if k <= -2.8e-153: tmp = t_1 elif k <= 2.1e+63: tmp = b * c 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(-27.0 * Float64(j * k)) tmp = 0.0 if (k <= -2.8e-153) tmp = t_1; elseif (k <= 2.1e+63) tmp = Float64(b * c); 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 = -27.0 * (j * k);
tmp = 0.0;
if (k <= -2.8e-153)
tmp = t_1;
elseif (k <= 2.1e+63)
tmp = b * c;
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[(-27.0 * N[(j * k), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -2.8e-153], t$95$1, If[LessEqual[k, 2.1e+63], N[(b * c), $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 := -27 \cdot \left(j \cdot k\right)\\
\mathbf{if}\;k \leq -2.8 \cdot 10^{-153}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 2.1 \cdot 10^{+63}:\\
\;\;\;\;b \cdot c\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -2.8000000000000001e-153 or 2.1000000000000002e63 < k Initial 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
Simplified82.0%
Taylor expanded in j around inf
*-lowering-*.f64N/A
*-lowering-*.f6438.3%
Simplified38.3%
if -2.8000000000000001e-153 < k < 2.1000000000000002e63Initial program 88.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
Simplified87.6%
Taylor expanded in b around inf
*-lowering-*.f6428.0%
Simplified28.0%
NOTE: x, y, z, t, a, b, c, i, j, and k should be sorted in increasing order before calling this function. (FPCore (x y z t a b c i j k) :precision binary64 (* 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 84.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
Simplified84.5%
Taylor expanded in b around inf
*-lowering-*.f6423.0%
Simplified23.0%
(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 2024158
(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)))