
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
real(8) function code(x, y, z, t, a, b, c, i)
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
code = 2.0d0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(Float64(a + Float64(b * c)) * c) * i))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i)); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
real(8) function code(x, y, z, t, a, b, c, i)
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
code = 2.0d0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(Float64(a + Float64(b * c)) * c) * i))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i)); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right)
\end{array}
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c))))
(if (<= (- (+ (* x y) (* z t)) (* (* c t_1) i)) INFINITY)
(* (+ (* x y) (- (* z t) (* t_1 (* c i)))) 2.0)
(* i (* t_1 (* c -2.0))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double tmp;
if ((((x * y) + (z * t)) - ((c * t_1) * i)) <= ((double) INFINITY)) {
tmp = ((x * y) + ((z * t) - (t_1 * (c * i)))) * 2.0;
} else {
tmp = i * (t_1 * (c * -2.0));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double tmp;
if ((((x * y) + (z * t)) - ((c * t_1) * i)) <= Double.POSITIVE_INFINITY) {
tmp = ((x * y) + ((z * t) - (t_1 * (c * i)))) * 2.0;
} else {
tmp = i * (t_1 * (c * -2.0));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) tmp = 0 if (((x * y) + (z * t)) - ((c * t_1) * i)) <= math.inf: tmp = ((x * y) + ((z * t) - (t_1 * (c * i)))) * 2.0 else: tmp = i * (t_1 * (c * -2.0)) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) tmp = 0.0 if (Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(c * t_1) * i)) <= Inf) tmp = Float64(Float64(Float64(x * y) + Float64(Float64(z * t) - Float64(t_1 * Float64(c * i)))) * 2.0); else tmp = Float64(i * Float64(t_1 * Float64(c * -2.0))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); tmp = 0.0; if ((((x * y) + (z * t)) - ((c * t_1) * i)) <= Inf) tmp = ((x * y) + ((z * t) - (t_1 * (c * i)))) * 2.0; else tmp = i * (t_1 * (c * -2.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] - N[(t$95$1 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(i * N[(t$95$1 * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
\mathbf{if}\;\left(x \cdot y + z \cdot t\right) - \left(c \cdot t\_1\right) \cdot i \leq \infty:\\
\;\;\;\;\left(x \cdot y + \left(z \cdot t - t\_1 \cdot \left(c \cdot i\right)\right)\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(t\_1 \cdot \left(c \cdot -2\right)\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) < +inf.0Initial program 93.1%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6491.8%
Simplified91.8%
*-commutativeN/A
associate--r-N/A
fmm-defN/A
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
fmm-defN/A
associate--l+N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Applied egg-rr98.0%
if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) Initial program 0.0%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f640.0%
Simplified0.0%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6487.5%
Simplified87.5%
Final simplification97.7%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c)))
(t_2 (* (* c -2.0) (* i t_1)))
(t_3 (* (* c t_1) i))
(t_4 (* 2.0 (- (* z t) t_3))))
(if (<= t_3 (- INFINITY))
t_2
(if (<= t_3 -5e+70)
t_4
(if (<= t_3 0.01)
(* (+ (* x y) (* z t)) 2.0)
(if (<= t_3 5e+267) t_4 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * -2.0) * (i * t_1);
double t_3 = (c * t_1) * i;
double t_4 = 2.0 * ((z * t) - t_3);
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = t_2;
} else if (t_3 <= -5e+70) {
tmp = t_4;
} else if (t_3 <= 0.01) {
tmp = ((x * y) + (z * t)) * 2.0;
} else if (t_3 <= 5e+267) {
tmp = t_4;
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * -2.0) * (i * t_1);
double t_3 = (c * t_1) * i;
double t_4 = 2.0 * ((z * t) - t_3);
double tmp;
if (t_3 <= -Double.POSITIVE_INFINITY) {
tmp = t_2;
} else if (t_3 <= -5e+70) {
tmp = t_4;
} else if (t_3 <= 0.01) {
tmp = ((x * y) + (z * t)) * 2.0;
} else if (t_3 <= 5e+267) {
tmp = t_4;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) t_2 = (c * -2.0) * (i * t_1) t_3 = (c * t_1) * i t_4 = 2.0 * ((z * t) - t_3) tmp = 0 if t_3 <= -math.inf: tmp = t_2 elif t_3 <= -5e+70: tmp = t_4 elif t_3 <= 0.01: tmp = ((x * y) + (z * t)) * 2.0 elif t_3 <= 5e+267: tmp = t_4 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) t_2 = Float64(Float64(c * -2.0) * Float64(i * t_1)) t_3 = Float64(Float64(c * t_1) * i) t_4 = Float64(2.0 * Float64(Float64(z * t) - t_3)) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = t_2; elseif (t_3 <= -5e+70) tmp = t_4; elseif (t_3 <= 0.01) tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0); elseif (t_3 <= 5e+267) tmp = t_4; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); t_2 = (c * -2.0) * (i * t_1); t_3 = (c * t_1) * i; t_4 = 2.0 * ((z * t) - t_3); tmp = 0.0; if (t_3 <= -Inf) tmp = t_2; elseif (t_3 <= -5e+70) tmp = t_4; elseif (t_3 <= 0.01) tmp = ((x * y) + (z * t)) * 2.0; elseif (t_3 <= 5e+267) tmp = t_4; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * -2.0), $MachinePrecision] * N[(i * t$95$1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]}, Block[{t$95$4 = N[(2.0 * N[(N[(z * t), $MachinePrecision] - t$95$3), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], t$95$2, If[LessEqual[t$95$3, -5e+70], t$95$4, If[LessEqual[t$95$3, 0.01], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$3, 5e+267], t$95$4, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
t_2 := \left(c \cdot -2\right) \cdot \left(i \cdot t\_1\right)\\
t_3 := \left(c \cdot t\_1\right) \cdot i\\
t_4 := 2 \cdot \left(z \cdot t - t\_3\right)\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq -5 \cdot 10^{+70}:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\
\mathbf{elif}\;t\_3 \leq 5 \cdot 10^{+267}:\\
\;\;\;\;t\_4\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -inf.0 or 4.9999999999999999e267 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 70.7%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.0%
Simplified87.0%
*-commutativeN/A
associate--r-N/A
fmm-defN/A
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
fmm-defN/A
associate--l+N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Applied egg-rr87.0%
Taylor expanded in i around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
if -inf.0 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -5.0000000000000002e70 or 0.0100000000000000002 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 4.9999999999999999e267Initial program 99.8%
Taylor expanded in x around 0
*-lowering-*.f6477.0%
Simplified77.0%
if -5.0000000000000002e70 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 0.0100000000000000002Initial program 99.9%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6499.9%
Simplified99.9%
Taylor expanded in c around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6494.6%
Simplified94.6%
Final simplification89.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c)))
(t_2 (* (* c -2.0) (* i t_1)))
(t_3 (* (* c t_1) i)))
(if (<= t_3 (- INFINITY))
t_2
(if (<= t_3 5e+267) (* (- (+ (* x y) (* z t)) t_3) 2.0) t_2))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * -2.0) * (i * t_1);
double t_3 = (c * t_1) * i;
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = t_2;
} else if (t_3 <= 5e+267) {
tmp = (((x * y) + (z * t)) - t_3) * 2.0;
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * -2.0) * (i * t_1);
double t_3 = (c * t_1) * i;
double tmp;
if (t_3 <= -Double.POSITIVE_INFINITY) {
tmp = t_2;
} else if (t_3 <= 5e+267) {
tmp = (((x * y) + (z * t)) - t_3) * 2.0;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) t_2 = (c * -2.0) * (i * t_1) t_3 = (c * t_1) * i tmp = 0 if t_3 <= -math.inf: tmp = t_2 elif t_3 <= 5e+267: tmp = (((x * y) + (z * t)) - t_3) * 2.0 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) t_2 = Float64(Float64(c * -2.0) * Float64(i * t_1)) t_3 = Float64(Float64(c * t_1) * i) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = t_2; elseif (t_3 <= 5e+267) tmp = Float64(Float64(Float64(Float64(x * y) + Float64(z * t)) - t_3) * 2.0); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); t_2 = (c * -2.0) * (i * t_1); t_3 = (c * t_1) * i; tmp = 0.0; if (t_3 <= -Inf) tmp = t_2; elseif (t_3 <= 5e+267) tmp = (((x * y) + (z * t)) - t_3) * 2.0; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * -2.0), $MachinePrecision] * N[(i * t$95$1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], t$95$2, If[LessEqual[t$95$3, 5e+267], N[(N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - t$95$3), $MachinePrecision] * 2.0), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
t_2 := \left(c \cdot -2\right) \cdot \left(i \cdot t\_1\right)\\
t_3 := \left(c \cdot t\_1\right) \cdot i\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq 5 \cdot 10^{+267}:\\
\;\;\;\;\left(\left(x \cdot y + z \cdot t\right) - t\_3\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -inf.0 or 4.9999999999999999e267 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 70.7%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.0%
Simplified87.0%
*-commutativeN/A
associate--r-N/A
fmm-defN/A
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
fmm-defN/A
associate--l+N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Applied egg-rr87.0%
Taylor expanded in i around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
if -inf.0 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 4.9999999999999999e267Initial program 99.9%
Final simplification96.8%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c))) (t_2 (* i t_1)) (t_3 (* (* c t_1) i)))
(if (<= t_3 (- INFINITY))
(* (* c -2.0) t_2)
(if (<= t_3 2e+157)
(* 2.0 (- (+ (* x y) (* z t)) (* i (* a c))))
(* 2.0 (- (* z t) (* c t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = i * t_1;
double t_3 = (c * t_1) * i;
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = (c * -2.0) * t_2;
} else if (t_3 <= 2e+157) {
tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
} else {
tmp = 2.0 * ((z * t) - (c * t_2));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = i * t_1;
double t_3 = (c * t_1) * i;
double tmp;
if (t_3 <= -Double.POSITIVE_INFINITY) {
tmp = (c * -2.0) * t_2;
} else if (t_3 <= 2e+157) {
tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
} else {
tmp = 2.0 * ((z * t) - (c * t_2));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) t_2 = i * t_1 t_3 = (c * t_1) * i tmp = 0 if t_3 <= -math.inf: tmp = (c * -2.0) * t_2 elif t_3 <= 2e+157: tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c))) else: tmp = 2.0 * ((z * t) - (c * t_2)) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) t_2 = Float64(i * t_1) t_3 = Float64(Float64(c * t_1) * i) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = Float64(Float64(c * -2.0) * t_2); elseif (t_3 <= 2e+157) tmp = Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(i * Float64(a * c)))); else tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * t_2))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); t_2 = i * t_1; t_3 = (c * t_1) * i; tmp = 0.0; if (t_3 <= -Inf) tmp = (c * -2.0) * t_2; elseif (t_3 <= 2e+157) tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c))); else tmp = 2.0 * ((z * t) - (c * t_2)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], N[(N[(c * -2.0), $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 2e+157], N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(i * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
t_2 := i \cdot t\_1\\
t_3 := \left(c \cdot t\_1\right) \cdot i\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;\left(c \cdot -2\right) \cdot t\_2\\
\mathbf{elif}\;t\_3 \leq 2 \cdot 10^{+157}:\\
\;\;\;\;2 \cdot \left(\left(x \cdot y + z \cdot t\right) - i \cdot \left(a \cdot c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot t\_2\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -inf.0Initial program 79.0%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6493.2%
Simplified93.2%
*-commutativeN/A
associate--r-N/A
fmm-defN/A
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
fmm-defN/A
associate--l+N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Applied egg-rr93.3%
Taylor expanded in i around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6495.7%
Simplified95.7%
if -inf.0 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.99999999999999997e157Initial program 99.9%
Taylor expanded in a around inf
*-commutativeN/A
*-lowering-*.f6495.5%
Simplified95.5%
if 1.99999999999999997e157 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 72.7%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6477.4%
Simplified77.4%
*-commutativeN/A
associate--r-N/A
fmm-defN/A
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
fmm-defN/A
associate--l+N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Applied egg-rr85.8%
Taylor expanded in x around 0
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6479.1%
Simplified79.1%
Final simplification91.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ a (* b c)))
(t_2 (* (* c -2.0) (* i t_1)))
(t_3 (* (* c t_1) i)))
(if (<= t_3 (- INFINITY))
t_2
(if (<= t_3 5e+267) (* 2.0 (- (+ (* x y) (* z t)) (* i (* a c)))) t_2))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * -2.0) * (i * t_1);
double t_3 = (c * t_1) * i;
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = t_2;
} else if (t_3 <= 5e+267) {
tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a + (b * c);
double t_2 = (c * -2.0) * (i * t_1);
double t_3 = (c * t_1) * i;
double tmp;
if (t_3 <= -Double.POSITIVE_INFINITY) {
tmp = t_2;
} else if (t_3 <= 5e+267) {
tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a + (b * c) t_2 = (c * -2.0) * (i * t_1) t_3 = (c * t_1) * i tmp = 0 if t_3 <= -math.inf: tmp = t_2 elif t_3 <= 5e+267: tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a + Float64(b * c)) t_2 = Float64(Float64(c * -2.0) * Float64(i * t_1)) t_3 = Float64(Float64(c * t_1) * i) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = t_2; elseif (t_3 <= 5e+267) tmp = Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(i * Float64(a * c)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a + (b * c); t_2 = (c * -2.0) * (i * t_1); t_3 = (c * t_1) * i; tmp = 0.0; if (t_3 <= -Inf) tmp = t_2; elseif (t_3 <= 5e+267) tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * -2.0), $MachinePrecision] * N[(i * t$95$1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(c * t$95$1), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], t$95$2, If[LessEqual[t$95$3, 5e+267], N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(i * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a + b \cdot c\\
t_2 := \left(c \cdot -2\right) \cdot \left(i \cdot t\_1\right)\\
t_3 := \left(c \cdot t\_1\right) \cdot i\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq 5 \cdot 10^{+267}:\\
\;\;\;\;2 \cdot \left(\left(x \cdot y + z \cdot t\right) - i \cdot \left(a \cdot c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -inf.0 or 4.9999999999999999e267 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 70.7%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.0%
Simplified87.0%
*-commutativeN/A
associate--r-N/A
fmm-defN/A
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
fmm-defN/A
associate--l+N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Applied egg-rr87.0%
Taylor expanded in i around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6490.7%
Simplified90.7%
if -inf.0 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 4.9999999999999999e267Initial program 99.9%
Taylor expanded in a around inf
*-commutativeN/A
*-lowering-*.f6492.3%
Simplified92.3%
Final simplification91.8%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* 2.0 (+ (* x y) (- (* z t) (* c (* i (+ a (* b c)))))))))
(if (<= c -1.5e-202)
t_1
(if (<= c 5.6e-52) (* 2.0 (- (+ (* x y) (* z t)) (* i (* a c)))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = 2.0 * ((x * y) + ((z * t) - (c * (i * (a + (b * c))))));
double tmp;
if (c <= -1.5e-202) {
tmp = t_1;
} else if (c <= 5.6e-52) {
tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: t_1
real(8) :: tmp
t_1 = 2.0d0 * ((x * y) + ((z * t) - (c * (i * (a + (b * c))))))
if (c <= (-1.5d-202)) then
tmp = t_1
else if (c <= 5.6d-52) then
tmp = 2.0d0 * (((x * y) + (z * t)) - (i * (a * c)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = 2.0 * ((x * y) + ((z * t) - (c * (i * (a + (b * c))))));
double tmp;
if (c <= -1.5e-202) {
tmp = t_1;
} else if (c <= 5.6e-52) {
tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = 2.0 * ((x * y) + ((z * t) - (c * (i * (a + (b * c)))))) tmp = 0 if c <= -1.5e-202: tmp = t_1 elif c <= 5.6e-52: tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(2.0 * Float64(Float64(x * y) + Float64(Float64(z * t) - Float64(c * Float64(i * Float64(a + Float64(b * c))))))) tmp = 0.0 if (c <= -1.5e-202) tmp = t_1; elseif (c <= 5.6e-52) tmp = Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(i * Float64(a * c)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = 2.0 * ((x * y) + ((z * t) - (c * (i * (a + (b * c)))))); tmp = 0.0; if (c <= -1.5e-202) tmp = t_1; elseif (c <= 5.6e-52) tmp = 2.0 * (((x * y) + (z * t)) - (i * (a * c))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(2.0 * N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] - N[(c * N[(i * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.5e-202], t$95$1, If[LessEqual[c, 5.6e-52], N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(i * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 \cdot \left(x \cdot y + \left(z \cdot t - c \cdot \left(i \cdot \left(a + b \cdot c\right)\right)\right)\right)\\
\mathbf{if}\;c \leq -1.5 \cdot 10^{-202}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 5.6 \cdot 10^{-52}:\\
\;\;\;\;2 \cdot \left(\left(x \cdot y + z \cdot t\right) - i \cdot \left(a \cdot c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -1.50000000000000005e-202 or 5.59999999999999989e-52 < c Initial program 85.2%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6491.8%
Simplified91.8%
if -1.50000000000000005e-202 < c < 5.59999999999999989e-52Initial program 99.9%
Taylor expanded in a around inf
*-commutativeN/A
*-lowering-*.f6499.9%
Simplified99.9%
Final simplification94.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* x y) 2.0)))
(if (<= (* x y) -6.5e-78)
t_1
(if (<= (* x y) -6.6e-200)
(* a (* c (* i -2.0)))
(if (<= (* x y) 1.6e-51) (* 2.0 (* z t)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * y) * 2.0;
double tmp;
if ((x * y) <= -6.5e-78) {
tmp = t_1;
} else if ((x * y) <= -6.6e-200) {
tmp = a * (c * (i * -2.0));
} else if ((x * y) <= 1.6e-51) {
tmp = 2.0 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: t_1
real(8) :: tmp
t_1 = (x * y) * 2.0d0
if ((x * y) <= (-6.5d-78)) then
tmp = t_1
else if ((x * y) <= (-6.6d-200)) then
tmp = a * (c * (i * (-2.0d0)))
else if ((x * y) <= 1.6d-51) then
tmp = 2.0d0 * (z * t)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * y) * 2.0;
double tmp;
if ((x * y) <= -6.5e-78) {
tmp = t_1;
} else if ((x * y) <= -6.6e-200) {
tmp = a * (c * (i * -2.0));
} else if ((x * y) <= 1.6e-51) {
tmp = 2.0 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * y) * 2.0 tmp = 0 if (x * y) <= -6.5e-78: tmp = t_1 elif (x * y) <= -6.6e-200: tmp = a * (c * (i * -2.0)) elif (x * y) <= 1.6e-51: tmp = 2.0 * (z * t) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * y) * 2.0) tmp = 0.0 if (Float64(x * y) <= -6.5e-78) tmp = t_1; elseif (Float64(x * y) <= -6.6e-200) tmp = Float64(a * Float64(c * Float64(i * -2.0))); elseif (Float64(x * y) <= 1.6e-51) tmp = Float64(2.0 * Float64(z * t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * y) * 2.0; tmp = 0.0; if ((x * y) <= -6.5e-78) tmp = t_1; elseif ((x * y) <= -6.6e-200) tmp = a * (c * (i * -2.0)); elseif ((x * y) <= 1.6e-51) tmp = 2.0 * (z * t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] * 2.0), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -6.5e-78], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -6.6e-200], N[(a * N[(c * N[(i * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.6e-51], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot y\right) \cdot 2\\
\mathbf{if}\;x \cdot y \leq -6.5 \cdot 10^{-78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq -6.6 \cdot 10^{-200}:\\
\;\;\;\;a \cdot \left(c \cdot \left(i \cdot -2\right)\right)\\
\mathbf{elif}\;x \cdot y \leq 1.6 \cdot 10^{-51}:\\
\;\;\;\;2 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -6.5000000000000003e-78 or 1.6e-51 < (*.f64 x y) Initial program 88.7%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.4%
Simplified87.4%
Taylor expanded in x around inf
*-lowering-*.f64N/A
*-lowering-*.f6451.4%
Simplified51.4%
if -6.5000000000000003e-78 < (*.f64 x y) < -6.5999999999999995e-200Initial program 95.0%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.5%
Simplified85.5%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6456.1%
Simplified56.1%
if -6.5999999999999995e-200 < (*.f64 x y) < 1.6e-51Initial program 91.6%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6492.8%
Simplified92.8%
Taylor expanded in z around inf
*-lowering-*.f64N/A
*-lowering-*.f6449.7%
Simplified49.7%
Final simplification51.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* c -2.0) (* i (+ a (* b c))))))
(if (<= c -7.2e+74)
t_1
(if (<= c 8.4e+68) (* (+ (* x y) (* z t)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (c * -2.0) * (i * (a + (b * c)));
double tmp;
if (c <= -7.2e+74) {
tmp = t_1;
} else if (c <= 8.4e+68) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: t_1
real(8) :: tmp
t_1 = (c * (-2.0d0)) * (i * (a + (b * c)))
if (c <= (-7.2d+74)) then
tmp = t_1
else if (c <= 8.4d+68) then
tmp = ((x * y) + (z * t)) * 2.0d0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (c * -2.0) * (i * (a + (b * c)));
double tmp;
if (c <= -7.2e+74) {
tmp = t_1;
} else if (c <= 8.4e+68) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (c * -2.0) * (i * (a + (b * c))) tmp = 0 if c <= -7.2e+74: tmp = t_1 elif c <= 8.4e+68: tmp = ((x * y) + (z * t)) * 2.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(c * -2.0) * Float64(i * Float64(a + Float64(b * c)))) tmp = 0.0 if (c <= -7.2e+74) tmp = t_1; elseif (c <= 8.4e+68) tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (c * -2.0) * (i * (a + (b * c))); tmp = 0.0; if (c <= -7.2e+74) tmp = t_1; elseif (c <= 8.4e+68) tmp = ((x * y) + (z * t)) * 2.0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * -2.0), $MachinePrecision] * N[(i * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -7.2e+74], t$95$1, If[LessEqual[c, 8.4e+68], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot -2\right) \cdot \left(i \cdot \left(a + b \cdot c\right)\right)\\
\mathbf{if}\;c \leq -7.2 \cdot 10^{+74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 8.4 \cdot 10^{+68}:\\
\;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -7.19999999999999975e74 or 8.40000000000000003e68 < c Initial program 77.3%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6493.0%
Simplified93.0%
*-commutativeN/A
associate--r-N/A
fmm-defN/A
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
fmm-defN/A
associate--l+N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
Applied egg-rr93.1%
Taylor expanded in i around inf
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6484.6%
Simplified84.6%
if -7.19999999999999975e74 < c < 8.40000000000000003e68Initial program 96.9%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6486.8%
Simplified86.8%
Taylor expanded in c around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.4%
Simplified74.4%
Final simplification77.9%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= c -1e+75)
(* c (* -2.0 (* b (* c i))))
(if (<= c 1.7e+70)
(* (+ (* x y) (* z t)) 2.0)
(* i (* (+ a (* b c)) (* c -2.0))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -1e+75) {
tmp = c * (-2.0 * (b * (c * i)));
} else if (c <= 1.7e+70) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = i * ((a + (b * c)) * (c * -2.0));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: tmp
if (c <= (-1d+75)) then
tmp = c * ((-2.0d0) * (b * (c * i)))
else if (c <= 1.7d+70) then
tmp = ((x * y) + (z * t)) * 2.0d0
else
tmp = i * ((a + (b * c)) * (c * (-2.0d0)))
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 tmp;
if (c <= -1e+75) {
tmp = c * (-2.0 * (b * (c * i)));
} else if (c <= 1.7e+70) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = i * ((a + (b * c)) * (c * -2.0));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if c <= -1e+75: tmp = c * (-2.0 * (b * (c * i))) elif c <= 1.7e+70: tmp = ((x * y) + (z * t)) * 2.0 else: tmp = i * ((a + (b * c)) * (c * -2.0)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (c <= -1e+75) tmp = Float64(c * Float64(-2.0 * Float64(b * Float64(c * i)))); elseif (c <= 1.7e+70) tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0); else tmp = Float64(i * Float64(Float64(a + Float64(b * c)) * Float64(c * -2.0))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (c <= -1e+75) tmp = c * (-2.0 * (b * (c * i))); elseif (c <= 1.7e+70) tmp = ((x * y) + (z * t)) * 2.0; else tmp = i * ((a + (b * c)) * (c * -2.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[c, -1e+75], N[(c * N[(-2.0 * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.7e+70], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(i * N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -1 \cdot 10^{+75}:\\
\;\;\;\;c \cdot \left(-2 \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\mathbf{elif}\;c \leq 1.7 \cdot 10^{+70}:\\
\;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(\left(a + b \cdot c\right) \cdot \left(c \cdot -2\right)\right)\\
\end{array}
\end{array}
if c < -9.99999999999999927e74Initial program 76.5%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6491.7%
Simplified91.7%
Taylor expanded in c around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6474.3%
Simplified74.3%
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6478.2%
Applied egg-rr78.2%
if -9.99999999999999927e74 < c < 1.7e70Initial program 96.9%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6486.8%
Simplified86.8%
Taylor expanded in c around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.4%
Simplified74.4%
if 1.7e70 < c Initial program 78.3%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6494.7%
Simplified94.7%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6471.2%
Simplified71.2%
Final simplification74.7%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= c -3.4e+74)
(* c (* -2.0 (* b (* c i))))
(if (<= c 2.4e+70)
(* (+ (* x y) (* z t)) 2.0)
(* (* c i) (* c (* b -2.0))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (c <= -3.4e+74) {
tmp = c * (-2.0 * (b * (c * i)));
} else if (c <= 2.4e+70) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = (c * i) * (c * (b * -2.0));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: tmp
if (c <= (-3.4d+74)) then
tmp = c * ((-2.0d0) * (b * (c * i)))
else if (c <= 2.4d+70) then
tmp = ((x * y) + (z * t)) * 2.0d0
else
tmp = (c * i) * (c * (b * (-2.0d0)))
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 tmp;
if (c <= -3.4e+74) {
tmp = c * (-2.0 * (b * (c * i)));
} else if (c <= 2.4e+70) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = (c * i) * (c * (b * -2.0));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if c <= -3.4e+74: tmp = c * (-2.0 * (b * (c * i))) elif c <= 2.4e+70: tmp = ((x * y) + (z * t)) * 2.0 else: tmp = (c * i) * (c * (b * -2.0)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (c <= -3.4e+74) tmp = Float64(c * Float64(-2.0 * Float64(b * Float64(c * i)))); elseif (c <= 2.4e+70) tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0); else tmp = Float64(Float64(c * i) * Float64(c * Float64(b * -2.0))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (c <= -3.4e+74) tmp = c * (-2.0 * (b * (c * i))); elseif (c <= 2.4e+70) tmp = ((x * y) + (z * t)) * 2.0; else tmp = (c * i) * (c * (b * -2.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[c, -3.4e+74], N[(c * N[(-2.0 * N[(b * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.4e+70], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(c * i), $MachinePrecision] * N[(c * N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.4 \cdot 10^{+74}:\\
\;\;\;\;c \cdot \left(-2 \cdot \left(b \cdot \left(c \cdot i\right)\right)\right)\\
\mathbf{elif}\;c \leq 2.4 \cdot 10^{+70}:\\
\;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(c \cdot i\right) \cdot \left(c \cdot \left(b \cdot -2\right)\right)\\
\end{array}
\end{array}
if c < -3.3999999999999999e74Initial program 76.5%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6491.7%
Simplified91.7%
Taylor expanded in c around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6474.3%
Simplified74.3%
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6478.2%
Applied egg-rr78.2%
if -3.3999999999999999e74 < c < 2.39999999999999987e70Initial program 96.9%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6486.8%
Simplified86.8%
Taylor expanded in c around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.4%
Simplified74.4%
if 2.39999999999999987e70 < c Initial program 78.3%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6494.7%
Simplified94.7%
Taylor expanded in c around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.3%
Simplified67.3%
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6467.5%
Applied egg-rr67.5%
Final simplification74.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* c i) (* c (* b -2.0)))))
(if (<= c -1.02e+75)
t_1
(if (<= c 9.5e+70) (* (+ (* x y) (* z t)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (c * i) * (c * (b * -2.0));
double tmp;
if (c <= -1.02e+75) {
tmp = t_1;
} else if (c <= 9.5e+70) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: t_1
real(8) :: tmp
t_1 = (c * i) * (c * (b * (-2.0d0)))
if (c <= (-1.02d+75)) then
tmp = t_1
else if (c <= 9.5d+70) then
tmp = ((x * y) + (z * t)) * 2.0d0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (c * i) * (c * (b * -2.0));
double tmp;
if (c <= -1.02e+75) {
tmp = t_1;
} else if (c <= 9.5e+70) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (c * i) * (c * (b * -2.0)) tmp = 0 if c <= -1.02e+75: tmp = t_1 elif c <= 9.5e+70: tmp = ((x * y) + (z * t)) * 2.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(c * i) * Float64(c * Float64(b * -2.0))) tmp = 0.0 if (c <= -1.02e+75) tmp = t_1; elseif (c <= 9.5e+70) tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (c * i) * (c * (b * -2.0)); tmp = 0.0; if (c <= -1.02e+75) tmp = t_1; elseif (c <= 9.5e+70) tmp = ((x * y) + (z * t)) * 2.0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * i), $MachinePrecision] * N[(c * N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.02e+75], t$95$1, If[LessEqual[c, 9.5e+70], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot i\right) \cdot \left(c \cdot \left(b \cdot -2\right)\right)\\
\mathbf{if}\;c \leq -1.02 \cdot 10^{+75}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 9.5 \cdot 10^{+70}:\\
\;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -1.0200000000000001e75 or 9.5000000000000002e70 < c Initial program 77.3%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6493.0%
Simplified93.0%
Taylor expanded in c around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6471.2%
Simplified71.2%
associate-*l*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6473.4%
Applied egg-rr73.4%
if -1.0200000000000001e75 < c < 9.5000000000000002e70Initial program 96.9%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6486.8%
Simplified86.8%
Taylor expanded in c around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.4%
Simplified74.4%
Final simplification74.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* c (* c (* i (* b -2.0))))))
(if (<= c -5.9e+75)
t_1
(if (<= c 5.6e+69) (* (+ (* x y) (* z t)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = c * (c * (i * (b * -2.0)));
double tmp;
if (c <= -5.9e+75) {
tmp = t_1;
} else if (c <= 5.6e+69) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: t_1
real(8) :: tmp
t_1 = c * (c * (i * (b * (-2.0d0))))
if (c <= (-5.9d+75)) then
tmp = t_1
else if (c <= 5.6d+69) then
tmp = ((x * y) + (z * t)) * 2.0d0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = c * (c * (i * (b * -2.0)));
double tmp;
if (c <= -5.9e+75) {
tmp = t_1;
} else if (c <= 5.6e+69) {
tmp = ((x * y) + (z * t)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = c * (c * (i * (b * -2.0))) tmp = 0 if c <= -5.9e+75: tmp = t_1 elif c <= 5.6e+69: tmp = ((x * y) + (z * t)) * 2.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(c * Float64(c * Float64(i * Float64(b * -2.0)))) tmp = 0.0 if (c <= -5.9e+75) tmp = t_1; elseif (c <= 5.6e+69) tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = c * (c * (i * (b * -2.0))); tmp = 0.0; if (c <= -5.9e+75) tmp = t_1; elseif (c <= 5.6e+69) tmp = ((x * y) + (z * t)) * 2.0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(c * N[(c * N[(i * N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -5.9e+75], t$95$1, If[LessEqual[c, 5.6e+69], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(c \cdot \left(i \cdot \left(b \cdot -2\right)\right)\right)\\
\mathbf{if}\;c \leq -5.9 \cdot 10^{+75}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 5.6 \cdot 10^{+69}:\\
\;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -5.89999999999999983e75 or 5.59999999999999964e69 < c Initial program 77.3%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6493.0%
Simplified93.0%
Taylor expanded in c around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6471.2%
Simplified71.2%
if -5.89999999999999983e75 < c < 5.59999999999999964e69Initial program 96.9%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6486.8%
Simplified86.8%
Taylor expanded in c around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.4%
Simplified74.4%
Final simplification73.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* x y) 2.0)))
(if (<= (* x y) -1.1e-72)
t_1
(if (<= (* x y) 1.15e-51) (* 2.0 (* z t)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * y) * 2.0;
double tmp;
if ((x * y) <= -1.1e-72) {
tmp = t_1;
} else if ((x * y) <= 1.15e-51) {
tmp = 2.0 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: t_1
real(8) :: tmp
t_1 = (x * y) * 2.0d0
if ((x * y) <= (-1.1d-72)) then
tmp = t_1
else if ((x * y) <= 1.15d-51) then
tmp = 2.0d0 * (z * t)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * y) * 2.0;
double tmp;
if ((x * y) <= -1.1e-72) {
tmp = t_1;
} else if ((x * y) <= 1.15e-51) {
tmp = 2.0 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * y) * 2.0 tmp = 0 if (x * y) <= -1.1e-72: tmp = t_1 elif (x * y) <= 1.15e-51: tmp = 2.0 * (z * t) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * y) * 2.0) tmp = 0.0 if (Float64(x * y) <= -1.1e-72) tmp = t_1; elseif (Float64(x * y) <= 1.15e-51) tmp = Float64(2.0 * Float64(z * t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * y) * 2.0; tmp = 0.0; if ((x * y) <= -1.1e-72) tmp = t_1; elseif ((x * y) <= 1.15e-51) tmp = 2.0 * (z * t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] * 2.0), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -1.1e-72], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 1.15e-51], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot y\right) \cdot 2\\
\mathbf{if}\;x \cdot y \leq -1.1 \cdot 10^{-72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq 1.15 \cdot 10^{-51}:\\
\;\;\;\;2 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -1.10000000000000001e-72 or 1.15000000000000001e-51 < (*.f64 x y) Initial program 88.6%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6487.2%
Simplified87.2%
Taylor expanded in x around inf
*-lowering-*.f64N/A
*-lowering-*.f6452.0%
Simplified52.0%
if -1.10000000000000001e-72 < (*.f64 x y) < 1.15000000000000001e-51Initial program 92.5%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6491.5%
Simplified91.5%
Taylor expanded in z around inf
*-lowering-*.f64N/A
*-lowering-*.f6444.0%
Simplified44.0%
Final simplification48.8%
(FPCore (x y z t a b c i) :precision binary64 (if (<= a -3.3e+187) (* a (* c (* i -2.0))) (* (+ (* x y) (* z t)) 2.0)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (a <= -3.3e+187) {
tmp = a * (c * (i * -2.0));
} else {
tmp = ((x * y) + (z * t)) * 2.0;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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) :: tmp
if (a <= (-3.3d+187)) then
tmp = a * (c * (i * (-2.0d0)))
else
tmp = ((x * y) + (z * t)) * 2.0d0
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 tmp;
if (a <= -3.3e+187) {
tmp = a * (c * (i * -2.0));
} else {
tmp = ((x * y) + (z * t)) * 2.0;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if a <= -3.3e+187: tmp = a * (c * (i * -2.0)) else: tmp = ((x * y) + (z * t)) * 2.0 return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (a <= -3.3e+187) tmp = Float64(a * Float64(c * Float64(i * -2.0))); else tmp = Float64(Float64(Float64(x * y) + Float64(z * t)) * 2.0); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (a <= -3.3e+187) tmp = a * (c * (i * -2.0)); else tmp = ((x * y) + (z * t)) * 2.0; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[a, -3.3e+187], N[(a * N[(c * N[(i * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.3 \cdot 10^{+187}:\\
\;\;\;\;a \cdot \left(c \cdot \left(i \cdot -2\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot y + z \cdot t\right) \cdot 2\\
\end{array}
\end{array}
if a < -3.3000000000000001e187Initial program 87.0%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.0%
Simplified74.0%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6466.5%
Simplified66.5%
if -3.3000000000000001e187 < a Initial program 90.6%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6490.9%
Simplified90.9%
Taylor expanded in c around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6461.2%
Simplified61.2%
Final simplification61.8%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (* z t)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (z * t);
}
real(8) function code(x, y, z, t, a, b, c, i)
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
code = 2.0d0 * (z * t)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (z * t);
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (z * t)
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(z * t)) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (z * t); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(z \cdot t\right)
\end{array}
Initial program 90.2%
*-lowering-*.f64N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
+-commutativeN/A
sub-negN/A
associate-+l-N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6489.0%
Simplified89.0%
Taylor expanded in z around inf
*-lowering-*.f64N/A
*-lowering-*.f6428.0%
Simplified28.0%
Final simplification28.0%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (+ a (* b c)) (* c i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)));
}
real(8) function code(x, y, z, t, a, b, c, i)
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
code = 2.0d0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(a + Float64(b * c)) * Float64(c * i)))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i))); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right)
\end{array}
herbie shell --seed 2024138
(FPCore (x y z t a b c i)
:name "Diagrams.ThreeD.Shapes:frustum from diagrams-lib-1.3.0.3, A"
:precision binary64
:alt
(! :herbie-platform default (* 2 (- (+ (* x y) (* z t)) (* (+ a (* b c)) (* c i)))))
(* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))