
(FPCore (x y z t a b c) :precision binary64 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
real(8) function code(x, y, z, t, a, b, c)
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
code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
def code(x, y, z, t, a, b, c): return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c) end
function tmp = code(x, y, z, t, a, b, c) tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c) :precision binary64 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
real(8) function code(x, y, z, t, a, b, c)
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
code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
def code(x, y, z, t, a, b, c): return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c) end
function tmp = code(x, y, z, t, a, b, c) tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c
\end{array}
(FPCore (x y z t a b c) :precision binary64 (+ (/ a (/ -4.0 b)) (+ (/ (* z t) 16.0) (+ (* x y) c))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (a / (-4.0 / b)) + (((z * t) / 16.0) + ((x * y) + c));
}
real(8) function code(x, y, z, t, a, b, c)
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
code = (a / ((-4.0d0) / b)) + (((z * t) / 16.0d0) + ((x * y) + c))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (a / (-4.0 / b)) + (((z * t) / 16.0) + ((x * y) + c));
}
def code(x, y, z, t, a, b, c): return (a / (-4.0 / b)) + (((z * t) / 16.0) + ((x * y) + c))
function code(x, y, z, t, a, b, c) return Float64(Float64(a / Float64(-4.0 / b)) + Float64(Float64(Float64(z * t) / 16.0) + Float64(Float64(x * y) + c))) end
function tmp = code(x, y, z, t, a, b, c) tmp = (a / (-4.0 / b)) + (((z * t) / 16.0) + ((x * y) + c)); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(a / N[(-4.0 / b), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{a}{\frac{-4}{b}} + \left(\frac{z \cdot t}{16} + \left(x \cdot y + c\right)\right)
\end{array}
Initial program 98.5%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6498.5%
Simplified98.5%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6498.8%
Applied egg-rr98.8%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* 0.0625 (* z t))) (t_2 (+ (* x y) (/ (* a b) -4.0))))
(if (<= (* a b) -5e-43)
t_2
(if (<= (* a b) 5e-184)
(+ (* x y) t_1)
(if (<= (* a b) 0.005) (+ c t_1) t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 0.0625 * (z * t);
double t_2 = (x * y) + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5e-43) {
tmp = t_2;
} else if ((a * b) <= 5e-184) {
tmp = (x * y) + t_1;
} else if ((a * b) <= 0.005) {
tmp = c + t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = 0.0625d0 * (z * t)
t_2 = (x * y) + ((a * b) / (-4.0d0))
if ((a * b) <= (-5d-43)) then
tmp = t_2
else if ((a * b) <= 5d-184) then
tmp = (x * y) + t_1
else if ((a * b) <= 0.005d0) then
tmp = c + t_1
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 t_1 = 0.0625 * (z * t);
double t_2 = (x * y) + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5e-43) {
tmp = t_2;
} else if ((a * b) <= 5e-184) {
tmp = (x * y) + t_1;
} else if ((a * b) <= 0.005) {
tmp = c + t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = 0.0625 * (z * t) t_2 = (x * y) + ((a * b) / -4.0) tmp = 0 if (a * b) <= -5e-43: tmp = t_2 elif (a * b) <= 5e-184: tmp = (x * y) + t_1 elif (a * b) <= 0.005: tmp = c + t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(0.0625 * Float64(z * t)) t_2 = Float64(Float64(x * y) + Float64(Float64(a * b) / -4.0)) tmp = 0.0 if (Float64(a * b) <= -5e-43) tmp = t_2; elseif (Float64(a * b) <= 5e-184) tmp = Float64(Float64(x * y) + t_1); elseif (Float64(a * b) <= 0.005) tmp = Float64(c + t_1); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = 0.0625 * (z * t); t_2 = (x * y) + ((a * b) / -4.0); tmp = 0.0; if ((a * b) <= -5e-43) tmp = t_2; elseif ((a * b) <= 5e-184) tmp = (x * y) + t_1; elseif ((a * b) <= 0.005) tmp = c + t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y), $MachinePrecision] + N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5e-43], t$95$2, If[LessEqual[N[(a * b), $MachinePrecision], 5e-184], N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 0.005], N[(c + t$95$1), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.0625 \cdot \left(z \cdot t\right)\\
t_2 := x \cdot y + \frac{a \cdot b}{-4}\\
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{-43}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{-184}:\\
\;\;\;\;x \cdot y + t\_1\\
\mathbf{elif}\;a \cdot b \leq 0.005:\\
\;\;\;\;c + t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000019e-43 or 0.0050000000000000001 < (*.f64 a b) Initial program 97.4%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.4%
Simplified97.4%
Taylor expanded in x around inf
*-lowering-*.f6472.5%
Simplified72.5%
if -5.00000000000000019e-43 < (*.f64 a b) < 5.00000000000000003e-184Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in c around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6478.5%
Simplified78.5%
if 5.00000000000000003e-184 < (*.f64 a b) < 0.0050000000000000001Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6496.5%
Simplified96.5%
Taylor expanded in c around inf
Simplified74.8%
Final simplification74.6%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* a b) -1e+238)
(* (* a b) -0.25)
(if (<= (* a b) -1e-53)
(+ (* x y) c)
(if (<= (* a b) 2e+163) (+ c (* 0.0625 (* z t))) (* a (/ b -4.0))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((a * b) <= -1e+238) {
tmp = (a * b) * -0.25;
} else if ((a * b) <= -1e-53) {
tmp = (x * y) + c;
} else if ((a * b) <= 2e+163) {
tmp = c + (0.0625 * (z * t));
} else {
tmp = a * (b / -4.0);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((a * b) <= (-1d+238)) then
tmp = (a * b) * (-0.25d0)
else if ((a * b) <= (-1d-53)) then
tmp = (x * y) + c
else if ((a * b) <= 2d+163) then
tmp = c + (0.0625d0 * (z * t))
else
tmp = a * (b / (-4.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 tmp;
if ((a * b) <= -1e+238) {
tmp = (a * b) * -0.25;
} else if ((a * b) <= -1e-53) {
tmp = (x * y) + c;
} else if ((a * b) <= 2e+163) {
tmp = c + (0.0625 * (z * t));
} else {
tmp = a * (b / -4.0);
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (a * b) <= -1e+238: tmp = (a * b) * -0.25 elif (a * b) <= -1e-53: tmp = (x * y) + c elif (a * b) <= 2e+163: tmp = c + (0.0625 * (z * t)) else: tmp = a * (b / -4.0) return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(a * b) <= -1e+238) tmp = Float64(Float64(a * b) * -0.25); elseif (Float64(a * b) <= -1e-53) tmp = Float64(Float64(x * y) + c); elseif (Float64(a * b) <= 2e+163) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); else tmp = Float64(a * Float64(b / -4.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((a * b) <= -1e+238) tmp = (a * b) * -0.25; elseif ((a * b) <= -1e-53) tmp = (x * y) + c; elseif ((a * b) <= 2e+163) tmp = c + (0.0625 * (z * t)); else tmp = a * (b / -4.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(a * b), $MachinePrecision], -1e+238], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], -1e-53], N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 2e+163], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a * N[(b / -4.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot b \leq -1 \cdot 10^{+238}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\mathbf{elif}\;a \cdot b \leq -1 \cdot 10^{-53}:\\
\;\;\;\;x \cdot y + c\\
\mathbf{elif}\;a \cdot b \leq 2 \cdot 10^{+163}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{b}{-4}\\
\end{array}
\end{array}
if (*.f64 a b) < -1e238Initial program 90.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6490.0%
Simplified90.0%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6490.3%
Simplified90.3%
if -1e238 < (*.f64 a b) < -1.00000000000000003e-53Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6471.3%
Simplified71.3%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6459.2%
Simplified59.2%
if -1.00000000000000003e-53 < (*.f64 a b) < 1.9999999999999999e163Initial program 99.3%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6499.3%
Simplified99.3%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6491.2%
Simplified91.2%
Taylor expanded in c around inf
Simplified61.8%
if 1.9999999999999999e163 < (*.f64 a b) Initial program 97.7%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.7%
Simplified97.7%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6486.6%
Simplified86.6%
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6488.8%
Applied egg-rr88.8%
Final simplification67.1%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ (* x y) c)) (t_2 (+ (/ (* a b) -4.0) t_1)))
(if (<= (* a b) -5e-43)
t_2
(if (<= (* a b) 2e-32) (+ t_1 (* 0.0625 (* z t))) t_2))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * y) + c;
double t_2 = ((a * b) / -4.0) + t_1;
double tmp;
if ((a * b) <= -5e-43) {
tmp = t_2;
} else if ((a * b) <= 2e-32) {
tmp = t_1 + (0.0625 * (z * t));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x * y) + c
t_2 = ((a * b) / (-4.0d0)) + t_1
if ((a * b) <= (-5d-43)) then
tmp = t_2
else if ((a * b) <= 2d-32) then
tmp = t_1 + (0.0625d0 * (z * t))
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 t_1 = (x * y) + c;
double t_2 = ((a * b) / -4.0) + t_1;
double tmp;
if ((a * b) <= -5e-43) {
tmp = t_2;
} else if ((a * b) <= 2e-32) {
tmp = t_1 + (0.0625 * (z * t));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (x * y) + c t_2 = ((a * b) / -4.0) + t_1 tmp = 0 if (a * b) <= -5e-43: tmp = t_2 elif (a * b) <= 2e-32: tmp = t_1 + (0.0625 * (z * t)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * y) + c) t_2 = Float64(Float64(Float64(a * b) / -4.0) + t_1) tmp = 0.0 if (Float64(a * b) <= -5e-43) tmp = t_2; elseif (Float64(a * b) <= 2e-32) tmp = Float64(t_1 + Float64(0.0625 * Float64(z * t))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (x * y) + c; t_2 = ((a * b) / -4.0) + t_1; tmp = 0.0; if ((a * b) <= -5e-43) tmp = t_2; elseif ((a * b) <= 2e-32) tmp = t_1 + (0.0625 * (z * t)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5e-43], t$95$2, If[LessEqual[N[(a * b), $MachinePrecision], 2e-32], N[(t$95$1 + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot y + c\\
t_2 := \frac{a \cdot b}{-4} + t\_1\\
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{-43}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \cdot b \leq 2 \cdot 10^{-32}:\\
\;\;\;\;t\_1 + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000019e-43 or 2.00000000000000011e-32 < (*.f64 a b) Initial program 97.4%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.4%
Simplified97.4%
Taylor expanded in z around 0
+-lowering-+.f64N/A
*-lowering-*.f6487.6%
Simplified87.6%
if -5.00000000000000019e-43 < (*.f64 a b) < 2.00000000000000011e-32Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Final simplification92.8%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* 0.0625 (* z t))))
(if (<= (* a b) -5e+223)
(+ c (/ (* a b) -4.0))
(if (<= (* a b) 1e+132) (+ (+ (* x y) c) t_1) (+ (/ a (/ -4.0 b)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 0.0625 * (z * t);
double tmp;
if ((a * b) <= -5e+223) {
tmp = c + ((a * b) / -4.0);
} else if ((a * b) <= 1e+132) {
tmp = ((x * y) + c) + t_1;
} else {
tmp = (a / (-4.0 / b)) + t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: tmp
t_1 = 0.0625d0 * (z * t)
if ((a * b) <= (-5d+223)) then
tmp = c + ((a * b) / (-4.0d0))
else if ((a * b) <= 1d+132) then
tmp = ((x * y) + c) + t_1
else
tmp = (a / ((-4.0d0) / b)) + 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 t_1 = 0.0625 * (z * t);
double tmp;
if ((a * b) <= -5e+223) {
tmp = c + ((a * b) / -4.0);
} else if ((a * b) <= 1e+132) {
tmp = ((x * y) + c) + t_1;
} else {
tmp = (a / (-4.0 / b)) + t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = 0.0625 * (z * t) tmp = 0 if (a * b) <= -5e+223: tmp = c + ((a * b) / -4.0) elif (a * b) <= 1e+132: tmp = ((x * y) + c) + t_1 else: tmp = (a / (-4.0 / b)) + t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(0.0625 * Float64(z * t)) tmp = 0.0 if (Float64(a * b) <= -5e+223) tmp = Float64(c + Float64(Float64(a * b) / -4.0)); elseif (Float64(a * b) <= 1e+132) tmp = Float64(Float64(Float64(x * y) + c) + t_1); else tmp = Float64(Float64(a / Float64(-4.0 / b)) + t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = 0.0625 * (z * t); tmp = 0.0; if ((a * b) <= -5e+223) tmp = c + ((a * b) / -4.0); elseif ((a * b) <= 1e+132) tmp = ((x * y) + c) + t_1; else tmp = (a / (-4.0 / b)) + t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5e+223], N[(c + N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 1e+132], N[(N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(a / N[(-4.0 / b), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{+223}:\\
\;\;\;\;c + \frac{a \cdot b}{-4}\\
\mathbf{elif}\;a \cdot b \leq 10^{+132}:\\
\;\;\;\;\left(x \cdot y + c\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{a}{\frac{-4}{b}} + t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -4.99999999999999985e223Initial program 90.9%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6490.9%
Simplified90.9%
Taylor expanded in c around inf
Simplified91.2%
if -4.99999999999999985e223 < (*.f64 a b) < 9.99999999999999991e131Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6487.0%
Simplified87.0%
if 9.99999999999999991e131 < (*.f64 a b) Initial program 95.6%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6495.6%
Simplified95.6%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6497.4%
Applied egg-rr97.4%
Taylor expanded in z around inf
*-lowering-*.f64N/A
*-lowering-*.f6490.3%
Simplified90.3%
Final simplification87.9%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (* a b) -4.0)))
(if (<= (* a b) -5e+223)
(+ c t_1)
(if (<= (* a b) 1e+141)
(+ (+ (* x y) c) (* 0.0625 (* z t)))
(+ (* x y) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (a * b) / -4.0;
double tmp;
if ((a * b) <= -5e+223) {
tmp = c + t_1;
} else if ((a * b) <= 1e+141) {
tmp = ((x * y) + c) + (0.0625 * (z * t));
} else {
tmp = (x * y) + t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: tmp
t_1 = (a * b) / (-4.0d0)
if ((a * b) <= (-5d+223)) then
tmp = c + t_1
else if ((a * b) <= 1d+141) then
tmp = ((x * y) + c) + (0.0625d0 * (z * t))
else
tmp = (x * y) + 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 t_1 = (a * b) / -4.0;
double tmp;
if ((a * b) <= -5e+223) {
tmp = c + t_1;
} else if ((a * b) <= 1e+141) {
tmp = ((x * y) + c) + (0.0625 * (z * t));
} else {
tmp = (x * y) + t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (a * b) / -4.0 tmp = 0 if (a * b) <= -5e+223: tmp = c + t_1 elif (a * b) <= 1e+141: tmp = ((x * y) + c) + (0.0625 * (z * t)) else: tmp = (x * y) + t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(a * b) / -4.0) tmp = 0.0 if (Float64(a * b) <= -5e+223) tmp = Float64(c + t_1); elseif (Float64(a * b) <= 1e+141) tmp = Float64(Float64(Float64(x * y) + c) + Float64(0.0625 * Float64(z * t))); else tmp = Float64(Float64(x * y) + t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (a * b) / -4.0; tmp = 0.0; if ((a * b) <= -5e+223) tmp = c + t_1; elseif ((a * b) <= 1e+141) tmp = ((x * y) + c) + (0.0625 * (z * t)); else tmp = (x * y) + t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5e+223], N[(c + t$95$1), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 1e+141], N[(N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{a \cdot b}{-4}\\
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{+223}:\\
\;\;\;\;c + t\_1\\
\mathbf{elif}\;a \cdot b \leq 10^{+141}:\\
\;\;\;\;\left(x \cdot y + c\right) + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y + t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -4.99999999999999985e223Initial program 90.9%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6490.9%
Simplified90.9%
Taylor expanded in c around inf
Simplified91.2%
if -4.99999999999999985e223 < (*.f64 a b) < 1.00000000000000002e141Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6487.1%
Simplified87.1%
if 1.00000000000000002e141 < (*.f64 a b) Initial program 95.5%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6495.5%
Simplified95.5%
Taylor expanded in x around inf
*-lowering-*.f6488.6%
Simplified88.6%
Final simplification87.7%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (/ (* a b) -4.0))))
(if (<= (* a b) -5.0)
t_1
(if (<= (* a b) 2e-32) (+ (* x y) (* 0.0625 (* z t))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = c + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5.0) {
tmp = t_1;
} else if ((a * b) <= 2e-32) {
tmp = (x * y) + (0.0625 * (z * t));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: tmp
t_1 = c + ((a * b) / (-4.0d0))
if ((a * b) <= (-5.0d0)) then
tmp = t_1
else if ((a * b) <= 2d-32) then
tmp = (x * y) + (0.0625d0 * (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 t_1 = c + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5.0) {
tmp = t_1;
} else if ((a * b) <= 2e-32) {
tmp = (x * y) + (0.0625 * (z * t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = c + ((a * b) / -4.0) tmp = 0 if (a * b) <= -5.0: tmp = t_1 elif (a * b) <= 2e-32: tmp = (x * y) + (0.0625 * (z * t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(c + Float64(Float64(a * b) / -4.0)) tmp = 0.0 if (Float64(a * b) <= -5.0) tmp = t_1; elseif (Float64(a * b) <= 2e-32) tmp = Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = c + ((a * b) / -4.0); tmp = 0.0; if ((a * b) <= -5.0) tmp = t_1; elseif ((a * b) <= 2e-32) tmp = (x * y) + (0.0625 * (z * t)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(c + N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5.0], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 2e-32], N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c + \frac{a \cdot b}{-4}\\
\mathbf{if}\;a \cdot b \leq -5:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 2 \cdot 10^{-32}:\\
\;\;\;\;x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -5 or 2.00000000000000011e-32 < (*.f64 a b) Initial program 97.3%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.3%
Simplified97.3%
Taylor expanded in c around inf
Simplified70.7%
if -5 < (*.f64 a b) < 2.00000000000000011e-32Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6498.3%
Simplified98.3%
Taylor expanded in c around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6474.3%
Simplified74.3%
Final simplification72.3%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (/ (* a b) -4.0))))
(if (<= (* a b) -5e-43)
t_1
(if (<= (* a b) 2e-32) (+ c (* 0.0625 (* z t))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = c + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5e-43) {
tmp = t_1;
} else if ((a * b) <= 2e-32) {
tmp = c + (0.0625 * (z * t));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: tmp
t_1 = c + ((a * b) / (-4.0d0))
if ((a * b) <= (-5d-43)) then
tmp = t_1
else if ((a * b) <= 2d-32) then
tmp = c + (0.0625d0 * (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 t_1 = c + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5e-43) {
tmp = t_1;
} else if ((a * b) <= 2e-32) {
tmp = c + (0.0625 * (z * t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = c + ((a * b) / -4.0) tmp = 0 if (a * b) <= -5e-43: tmp = t_1 elif (a * b) <= 2e-32: tmp = c + (0.0625 * (z * t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(c + Float64(Float64(a * b) / -4.0)) tmp = 0.0 if (Float64(a * b) <= -5e-43) tmp = t_1; elseif (Float64(a * b) <= 2e-32) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = c + ((a * b) / -4.0); tmp = 0.0; if ((a * b) <= -5e-43) tmp = t_1; elseif ((a * b) <= 2e-32) tmp = c + (0.0625 * (z * t)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(c + N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5e-43], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 2e-32], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c + \frac{a \cdot b}{-4}\\
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{-43}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 2 \cdot 10^{-32}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000019e-43 or 2.00000000000000011e-32 < (*.f64 a b) Initial program 97.4%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.4%
Simplified97.4%
Taylor expanded in c around inf
Simplified68.9%
if -5.00000000000000019e-43 < (*.f64 a b) < 2.00000000000000011e-32Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in c around inf
Simplified67.1%
Final simplification68.2%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* a b) -1e+238) (* (* a b) -0.25) (if (<= (* a b) 1e+132) (+ (* x y) c) (* a (/ b -4.0)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((a * b) <= -1e+238) {
tmp = (a * b) * -0.25;
} else if ((a * b) <= 1e+132) {
tmp = (x * y) + c;
} else {
tmp = a * (b / -4.0);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((a * b) <= (-1d+238)) then
tmp = (a * b) * (-0.25d0)
else if ((a * b) <= 1d+132) then
tmp = (x * y) + c
else
tmp = a * (b / (-4.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 tmp;
if ((a * b) <= -1e+238) {
tmp = (a * b) * -0.25;
} else if ((a * b) <= 1e+132) {
tmp = (x * y) + c;
} else {
tmp = a * (b / -4.0);
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (a * b) <= -1e+238: tmp = (a * b) * -0.25 elif (a * b) <= 1e+132: tmp = (x * y) + c else: tmp = a * (b / -4.0) return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(a * b) <= -1e+238) tmp = Float64(Float64(a * b) * -0.25); elseif (Float64(a * b) <= 1e+132) tmp = Float64(Float64(x * y) + c); else tmp = Float64(a * Float64(b / -4.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((a * b) <= -1e+238) tmp = (a * b) * -0.25; elseif ((a * b) <= 1e+132) tmp = (x * y) + c; else tmp = a * (b / -4.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(a * b), $MachinePrecision], -1e+238], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 1e+132], N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision], N[(a * N[(b / -4.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot b \leq -1 \cdot 10^{+238}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\mathbf{elif}\;a \cdot b \leq 10^{+132}:\\
\;\;\;\;x \cdot y + c\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{b}{-4}\\
\end{array}
\end{array}
if (*.f64 a b) < -1e238Initial program 90.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6490.0%
Simplified90.0%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6490.3%
Simplified90.3%
if -1e238 < (*.f64 a b) < 9.99999999999999991e131Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6486.6%
Simplified86.6%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6457.9%
Simplified57.9%
if 9.99999999999999991e131 < (*.f64 a b) Initial program 95.6%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6495.6%
Simplified95.6%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6479.4%
Simplified79.4%
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6481.3%
Applied egg-rr81.3%
Final simplification64.2%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* a b) -5e-43) (* (* a b) -0.25) (if (<= (* a b) 5e-31) (* 0.0625 (* z t)) (* a (/ b -4.0)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((a * b) <= -5e-43) {
tmp = (a * b) * -0.25;
} else if ((a * b) <= 5e-31) {
tmp = 0.0625 * (z * t);
} else {
tmp = a * (b / -4.0);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((a * b) <= (-5d-43)) then
tmp = (a * b) * (-0.25d0)
else if ((a * b) <= 5d-31) then
tmp = 0.0625d0 * (z * t)
else
tmp = a * (b / (-4.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 tmp;
if ((a * b) <= -5e-43) {
tmp = (a * b) * -0.25;
} else if ((a * b) <= 5e-31) {
tmp = 0.0625 * (z * t);
} else {
tmp = a * (b / -4.0);
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (a * b) <= -5e-43: tmp = (a * b) * -0.25 elif (a * b) <= 5e-31: tmp = 0.0625 * (z * t) else: tmp = a * (b / -4.0) return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(a * b) <= -5e-43) tmp = Float64(Float64(a * b) * -0.25); elseif (Float64(a * b) <= 5e-31) tmp = Float64(0.0625 * Float64(z * t)); else tmp = Float64(a * Float64(b / -4.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((a * b) <= -5e-43) tmp = (a * b) * -0.25; elseif ((a * b) <= 5e-31) tmp = 0.0625 * (z * t); else tmp = a * (b / -4.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(a * b), $MachinePrecision], -5e-43], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e-31], N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision], N[(a * N[(b / -4.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{-43}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{-31}:\\
\;\;\;\;0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{b}{-4}\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000019e-43Initial program 97.3%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.3%
Simplified97.3%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6446.3%
Simplified46.3%
if -5.00000000000000019e-43 < (*.f64 a b) < 5e-31Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in z around inf
*-lowering-*.f64N/A
*-lowering-*.f6442.3%
Simplified42.3%
if 5e-31 < (*.f64 a b) Initial program 97.5%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.5%
Simplified97.5%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6459.5%
Simplified59.5%
*-commutativeN/A
associate-*r*N/A
metadata-evalN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6460.6%
Applied egg-rr60.6%
Final simplification48.6%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* a b) -0.25)))
(if (<= (* a b) -7.2e-43)
t_1
(if (<= (* a b) 8.5e-18) (* 0.0625 (* z t)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (a * b) * -0.25;
double tmp;
if ((a * b) <= -7.2e-43) {
tmp = t_1;
} else if ((a * b) <= 8.5e-18) {
tmp = 0.0625 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: t_1
real(8) :: tmp
t_1 = (a * b) * (-0.25d0)
if ((a * b) <= (-7.2d-43)) then
tmp = t_1
else if ((a * b) <= 8.5d-18) then
tmp = 0.0625d0 * (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 t_1 = (a * b) * -0.25;
double tmp;
if ((a * b) <= -7.2e-43) {
tmp = t_1;
} else if ((a * b) <= 8.5e-18) {
tmp = 0.0625 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (a * b) * -0.25 tmp = 0 if (a * b) <= -7.2e-43: tmp = t_1 elif (a * b) <= 8.5e-18: tmp = 0.0625 * (z * t) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(a * b) * -0.25) tmp = 0.0 if (Float64(a * b) <= -7.2e-43) tmp = t_1; elseif (Float64(a * b) <= 8.5e-18) tmp = Float64(0.0625 * Float64(z * t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (a * b) * -0.25; tmp = 0.0; if ((a * b) <= -7.2e-43) tmp = t_1; elseif ((a * b) <= 8.5e-18) tmp = 0.0625 * (z * t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -7.2e-43], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 8.5e-18], N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot b\right) \cdot -0.25\\
\mathbf{if}\;a \cdot b \leq -7.2 \cdot 10^{-43}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 8.5 \cdot 10^{-18}:\\
\;\;\;\;0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -7.1999999999999998e-43 or 8.4999999999999995e-18 < (*.f64 a b) Initial program 97.4%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6497.4%
Simplified97.4%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6452.8%
Simplified52.8%
if -7.1999999999999998e-43 < (*.f64 a b) < 8.4999999999999995e-18Initial program 100.0%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64100.0%
Simplified100.0%
Taylor expanded in z around inf
*-lowering-*.f64N/A
*-lowering-*.f6442.3%
Simplified42.3%
Final simplification48.3%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* x y) -1.3e+59) (* x y) (if (<= (* x y) 5.8e+111) (* (* a b) -0.25) (* x y))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -1.3e+59) {
tmp = x * y;
} else if ((x * y) <= 5.8e+111) {
tmp = (a * b) * -0.25;
} else {
tmp = x * y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((x * y) <= (-1.3d+59)) then
tmp = x * y
else if ((x * y) <= 5.8d+111) then
tmp = (a * b) * (-0.25d0)
else
tmp = x * y
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 tmp;
if ((x * y) <= -1.3e+59) {
tmp = x * y;
} else if ((x * y) <= 5.8e+111) {
tmp = (a * b) * -0.25;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (x * y) <= -1.3e+59: tmp = x * y elif (x * y) <= 5.8e+111: tmp = (a * b) * -0.25 else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -1.3e+59) tmp = Float64(x * y); elseif (Float64(x * y) <= 5.8e+111) tmp = Float64(Float64(a * b) * -0.25); else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((x * y) <= -1.3e+59) tmp = x * y; elseif ((x * y) <= 5.8e+111) tmp = (a * b) * -0.25; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(x * y), $MachinePrecision], -1.3e+59], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 5.8e+111], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision], N[(x * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -1.3 \cdot 10^{+59}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq 5.8 \cdot 10^{+111}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -1.3e59 or 5.7999999999999999e111 < (*.f64 x y) Initial program 98.9%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6498.9%
Simplified98.9%
Taylor expanded in x around inf
*-lowering-*.f6463.8%
Simplified63.8%
if -1.3e59 < (*.f64 x y) < 5.7999999999999999e111Initial program 98.3%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6498.3%
Simplified98.3%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6438.2%
Simplified38.2%
Final simplification46.9%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* x y) -9e+178) (* x y) (if (<= (* x y) 1.3e-137) c (* x y))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -9e+178) {
tmp = x * y;
} else if ((x * y) <= 1.3e-137) {
tmp = c;
} else {
tmp = x * y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c)
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) :: tmp
if ((x * y) <= (-9d+178)) then
tmp = x * y
else if ((x * y) <= 1.3d-137) then
tmp = c
else
tmp = x * y
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 tmp;
if ((x * y) <= -9e+178) {
tmp = x * y;
} else if ((x * y) <= 1.3e-137) {
tmp = c;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (x * y) <= -9e+178: tmp = x * y elif (x * y) <= 1.3e-137: tmp = c else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -9e+178) tmp = Float64(x * y); elseif (Float64(x * y) <= 1.3e-137) tmp = c; else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((x * y) <= -9e+178) tmp = x * y; elseif ((x * y) <= 1.3e-137) tmp = c; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(x * y), $MachinePrecision], -9e+178], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 1.3e-137], c, N[(x * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -9 \cdot 10^{+178}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq 1.3 \cdot 10^{-137}:\\
\;\;\;\;c\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -8.9999999999999994e178 or 1.3e-137 < (*.f64 x y) Initial program 98.5%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6498.5%
Simplified98.5%
Taylor expanded in x around inf
*-lowering-*.f6451.8%
Simplified51.8%
if -8.9999999999999994e178 < (*.f64 x y) < 1.3e-137Initial program 98.5%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6498.5%
Simplified98.5%
Taylor expanded in c around inf
Simplified30.9%
(FPCore (x y z t a b c) :precision binary64 (+ c (- (+ (/ (* z t) 16.0) (* x y)) (/ (* a b) 4.0))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return c + ((((z * t) / 16.0) + (x * y)) - ((a * b) / 4.0));
}
real(8) function code(x, y, z, t, a, b, c)
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
code = c + ((((z * t) / 16.0d0) + (x * y)) - ((a * b) / 4.0d0))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return c + ((((z * t) / 16.0) + (x * y)) - ((a * b) / 4.0));
}
def code(x, y, z, t, a, b, c): return c + ((((z * t) / 16.0) + (x * y)) - ((a * b) / 4.0))
function code(x, y, z, t, a, b, c) return Float64(c + Float64(Float64(Float64(Float64(z * t) / 16.0) + Float64(x * y)) - Float64(Float64(a * b) / 4.0))) end
function tmp = code(x, y, z, t, a, b, c) tmp = c + ((((z * t) / 16.0) + (x * y)) - ((a * b) / 4.0)); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(c + N[(N[(N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
c + \left(\left(\frac{z \cdot t}{16} + x \cdot y\right) - \frac{a \cdot b}{4}\right)
\end{array}
Initial program 98.5%
Final simplification98.5%
(FPCore (x y z t a b c) :precision binary64 c)
double code(double x, double y, double z, double t, double a, double b, double c) {
return c;
}
real(8) function code(x, y, z, t, a, b, c)
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
code = c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return c;
}
def code(x, y, z, t, a, b, c): return c
function code(x, y, z, t, a, b, c) return c end
function tmp = code(x, y, z, t, a, b, c) tmp = c; end
code[x_, y_, z_, t_, a_, b_, c_] := c
\begin{array}{l}
\\
c
\end{array}
Initial program 98.5%
+-commutativeN/A
sub-negN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6498.5%
Simplified98.5%
Taylor expanded in c around inf
Simplified21.5%
herbie shell --seed 2024145
(FPCore (x y z t a b c)
:name "Diagrams.Solve.Polynomial:quartForm from diagrams-solve-0.1, C"
:precision binary64
(+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))