
(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 18 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 (- (+ (/ z (/ 16.0 t)) (+ (* x y) c)) (/ (* a b) 4.0)))
double code(double x, double y, double z, double t, double a, double b, double c) {
return ((z / (16.0 / t)) + ((x * y) + c)) - ((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 = ((z / (16.0d0 / t)) + ((x * y) + c)) - ((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 ((z / (16.0 / t)) + ((x * y) + c)) - ((a * b) / 4.0);
}
def code(x, y, z, t, a, b, c): return ((z / (16.0 / t)) + ((x * y) + c)) - ((a * b) / 4.0)
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(z / Float64(16.0 / t)) + Float64(Float64(x * y) + c)) - Float64(Float64(a * b) / 4.0)) end
function tmp = code(x, y, z, t, a, b, c) tmp = ((z / (16.0 / t)) + ((x * y) + c)) - ((a * b) / 4.0); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(z / N[(16.0 / t), $MachinePrecision]), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\frac{z}{\frac{16}{t}} + \left(x \cdot y + c\right)\right) - \frac{a \cdot b}{4}
\end{array}
Initial program 97.8%
+-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.8%
Simplified97.8%
+-commutativeN/A
frac-2negN/A
distribute-frac-negN/A
unsub-negN/A
--lowering--.f64N/A
+-lowering-+.f64N/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-eval98.1%
Applied egg-rr98.1%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* 0.0625 (* z t))))
(if (<= (* a b) -5e+150)
(* a (/ b -4.0))
(if (<= (* a b) -4e+84)
c
(if (<= (* a b) -5e-49)
(* x y)
(if (<= (* a b) -1e-163)
t_1
(if (<= (* a b) 1e+64)
c
(if (<= (* a b) 2e+107) t_1 (* (* a b) -0.25)))))))))
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+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= -4e+84) {
tmp = c;
} else if ((a * b) <= -5e-49) {
tmp = x * y;
} else if ((a * b) <= -1e-163) {
tmp = t_1;
} else if ((a * b) <= 1e+64) {
tmp = c;
} else if ((a * b) <= 2e+107) {
tmp = t_1;
} else {
tmp = (a * b) * -0.25;
}
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+150)) then
tmp = a * (b / (-4.0d0))
else if ((a * b) <= (-4d+84)) then
tmp = c
else if ((a * b) <= (-5d-49)) then
tmp = x * y
else if ((a * b) <= (-1d-163)) then
tmp = t_1
else if ((a * b) <= 1d+64) then
tmp = c
else if ((a * b) <= 2d+107) then
tmp = t_1
else
tmp = (a * b) * (-0.25d0)
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+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= -4e+84) {
tmp = c;
} else if ((a * b) <= -5e-49) {
tmp = x * y;
} else if ((a * b) <= -1e-163) {
tmp = t_1;
} else if ((a * b) <= 1e+64) {
tmp = c;
} else if ((a * b) <= 2e+107) {
tmp = t_1;
} else {
tmp = (a * b) * -0.25;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = 0.0625 * (z * t) tmp = 0 if (a * b) <= -5e+150: tmp = a * (b / -4.0) elif (a * b) <= -4e+84: tmp = c elif (a * b) <= -5e-49: tmp = x * y elif (a * b) <= -1e-163: tmp = t_1 elif (a * b) <= 1e+64: tmp = c elif (a * b) <= 2e+107: tmp = t_1 else: tmp = (a * b) * -0.25 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+150) tmp = Float64(a * Float64(b / -4.0)); elseif (Float64(a * b) <= -4e+84) tmp = c; elseif (Float64(a * b) <= -5e-49) tmp = Float64(x * y); elseif (Float64(a * b) <= -1e-163) tmp = t_1; elseif (Float64(a * b) <= 1e+64) tmp = c; elseif (Float64(a * b) <= 2e+107) tmp = t_1; else tmp = Float64(Float64(a * b) * -0.25); 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+150) tmp = a * (b / -4.0); elseif ((a * b) <= -4e+84) tmp = c; elseif ((a * b) <= -5e-49) tmp = x * y; elseif ((a * b) <= -1e-163) tmp = t_1; elseif ((a * b) <= 1e+64) tmp = c; elseif ((a * b) <= 2e+107) tmp = t_1; else tmp = (a * b) * -0.25; 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+150], N[(a * N[(b / -4.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], -4e+84], c, If[LessEqual[N[(a * b), $MachinePrecision], -5e-49], N[(x * y), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], -1e-163], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 1e+64], c, If[LessEqual[N[(a * b), $MachinePrecision], 2e+107], t$95$1, N[(N[(a * b), $MachinePrecision] * -0.25), $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^{+150}:\\
\;\;\;\;a \cdot \frac{b}{-4}\\
\mathbf{elif}\;a \cdot b \leq -4 \cdot 10^{+84}:\\
\;\;\;\;c\\
\mathbf{elif}\;a \cdot b \leq -5 \cdot 10^{-49}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;a \cdot b \leq -1 \cdot 10^{-163}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 10^{+64}:\\
\;\;\;\;c\\
\mathbf{elif}\;a \cdot b \leq 2 \cdot 10^{+107}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000009e150Initial program 97.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-*.f6497.9%
Simplified97.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6482.1%
Simplified82.1%
*-commutativeN/A
metadata-evalN/A
div-invN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6484.2%
Applied egg-rr84.2%
if -5.00000000000000009e150 < (*.f64 a b) < -4.00000000000000023e84 or -9.99999999999999923e-164 < (*.f64 a b) < 1.00000000000000002e64Initial program 98.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-*.f6498.6%
Simplified98.6%
Taylor expanded in c around inf
Simplified45.6%
if -4.00000000000000023e84 < (*.f64 a b) < -4.9999999999999999e-49Initial 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 x around inf
*-lowering-*.f6459.4%
Simplified59.4%
if -4.9999999999999999e-49 < (*.f64 a b) < -9.99999999999999923e-164 or 1.00000000000000002e64 < (*.f64 a b) < 1.9999999999999999e107Initial 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-*.f6472.6%
Simplified72.6%
if 1.9999999999999999e107 < (*.f64 a b) Initial program 94.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-*.f6494.0%
Simplified94.0%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6469.3%
Simplified69.3%
Final simplification58.8%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* 0.0625 (* z t))) (t_2 (* (* a b) -0.25)))
(if (<= (* a b) -6.5e+148)
t_2
(if (<= (* a b) -1.65e+83)
c
(if (<= (* a b) -1.55e-49)
(* x y)
(if (<= (* a b) -1.5e-175)
t_1
(if (<= (* a b) 3e+65) c (if (<= (* a b) 2.6e+111) 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 = (a * b) * -0.25;
double tmp;
if ((a * b) <= -6.5e+148) {
tmp = t_2;
} else if ((a * b) <= -1.65e+83) {
tmp = c;
} else if ((a * b) <= -1.55e-49) {
tmp = x * y;
} else if ((a * b) <= -1.5e-175) {
tmp = t_1;
} else if ((a * b) <= 3e+65) {
tmp = c;
} else if ((a * b) <= 2.6e+111) {
tmp = 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 = (a * b) * (-0.25d0)
if ((a * b) <= (-6.5d+148)) then
tmp = t_2
else if ((a * b) <= (-1.65d+83)) then
tmp = c
else if ((a * b) <= (-1.55d-49)) then
tmp = x * y
else if ((a * b) <= (-1.5d-175)) then
tmp = t_1
else if ((a * b) <= 3d+65) then
tmp = c
else if ((a * b) <= 2.6d+111) then
tmp = 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 = (a * b) * -0.25;
double tmp;
if ((a * b) <= -6.5e+148) {
tmp = t_2;
} else if ((a * b) <= -1.65e+83) {
tmp = c;
} else if ((a * b) <= -1.55e-49) {
tmp = x * y;
} else if ((a * b) <= -1.5e-175) {
tmp = t_1;
} else if ((a * b) <= 3e+65) {
tmp = c;
} else if ((a * b) <= 2.6e+111) {
tmp = 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 = (a * b) * -0.25 tmp = 0 if (a * b) <= -6.5e+148: tmp = t_2 elif (a * b) <= -1.65e+83: tmp = c elif (a * b) <= -1.55e-49: tmp = x * y elif (a * b) <= -1.5e-175: tmp = t_1 elif (a * b) <= 3e+65: tmp = c elif (a * b) <= 2.6e+111: tmp = 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(a * b) * -0.25) tmp = 0.0 if (Float64(a * b) <= -6.5e+148) tmp = t_2; elseif (Float64(a * b) <= -1.65e+83) tmp = c; elseif (Float64(a * b) <= -1.55e-49) tmp = Float64(x * y); elseif (Float64(a * b) <= -1.5e-175) tmp = t_1; elseif (Float64(a * b) <= 3e+65) tmp = c; elseif (Float64(a * b) <= 2.6e+111) tmp = 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 = (a * b) * -0.25; tmp = 0.0; if ((a * b) <= -6.5e+148) tmp = t_2; elseif ((a * b) <= -1.65e+83) tmp = c; elseif ((a * b) <= -1.55e-49) tmp = x * y; elseif ((a * b) <= -1.5e-175) tmp = t_1; elseif ((a * b) <= 3e+65) tmp = c; elseif ((a * b) <= 2.6e+111) tmp = 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[(a * b), $MachinePrecision] * -0.25), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -6.5e+148], t$95$2, If[LessEqual[N[(a * b), $MachinePrecision], -1.65e+83], c, If[LessEqual[N[(a * b), $MachinePrecision], -1.55e-49], N[(x * y), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], -1.5e-175], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 3e+65], c, If[LessEqual[N[(a * b), $MachinePrecision], 2.6e+111], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.0625 \cdot \left(z \cdot t\right)\\
t_2 := \left(a \cdot b\right) \cdot -0.25\\
\mathbf{if}\;a \cdot b \leq -6.5 \cdot 10^{+148}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \cdot b \leq -1.65 \cdot 10^{+83}:\\
\;\;\;\;c\\
\mathbf{elif}\;a \cdot b \leq -1.55 \cdot 10^{-49}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;a \cdot b \leq -1.5 \cdot 10^{-175}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 3 \cdot 10^{+65}:\\
\;\;\;\;c\\
\mathbf{elif}\;a \cdot b \leq 2.6 \cdot 10^{+111}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 a b) < -6.49999999999999947e148 or 2.5999999999999999e111 < (*.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-*.f6474.6%
Simplified74.6%
if -6.49999999999999947e148 < (*.f64 a b) < -1.64999999999999992e83 or -1.5e-175 < (*.f64 a b) < 3.0000000000000002e65Initial program 98.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-*.f6498.6%
Simplified98.6%
Taylor expanded in c around inf
Simplified45.6%
if -1.64999999999999992e83 < (*.f64 a b) < -1.55e-49Initial 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 x around inf
*-lowering-*.f6459.4%
Simplified59.4%
if -1.55e-49 < (*.f64 a b) < -1.5e-175 or 3.0000000000000002e65 < (*.f64 a b) < 2.5999999999999999e111Initial 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-*.f6472.6%
Simplified72.6%
Final simplification58.6%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* a b) -0.25)))
(if (<= (* a b) -8.2e+147)
t_1
(if (<= (* a b) -5e+82)
c
(if (<= (* a b) -2.1e-178) (* x y) (if (<= (* a b) 1.16e+61) c 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) <= -8.2e+147) {
tmp = t_1;
} else if ((a * b) <= -5e+82) {
tmp = c;
} else if ((a * b) <= -2.1e-178) {
tmp = x * y;
} else if ((a * b) <= 1.16e+61) {
tmp = c;
} 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) <= (-8.2d+147)) then
tmp = t_1
else if ((a * b) <= (-5d+82)) then
tmp = c
else if ((a * b) <= (-2.1d-178)) then
tmp = x * y
else if ((a * b) <= 1.16d+61) then
tmp = 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 t_1 = (a * b) * -0.25;
double tmp;
if ((a * b) <= -8.2e+147) {
tmp = t_1;
} else if ((a * b) <= -5e+82) {
tmp = c;
} else if ((a * b) <= -2.1e-178) {
tmp = x * y;
} else if ((a * b) <= 1.16e+61) {
tmp = c;
} 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) <= -8.2e+147: tmp = t_1 elif (a * b) <= -5e+82: tmp = c elif (a * b) <= -2.1e-178: tmp = x * y elif (a * b) <= 1.16e+61: tmp = c 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) <= -8.2e+147) tmp = t_1; elseif (Float64(a * b) <= -5e+82) tmp = c; elseif (Float64(a * b) <= -2.1e-178) tmp = Float64(x * y); elseif (Float64(a * b) <= 1.16e+61) tmp = c; 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) <= -8.2e+147) tmp = t_1; elseif ((a * b) <= -5e+82) tmp = c; elseif ((a * b) <= -2.1e-178) tmp = x * y; elseif ((a * b) <= 1.16e+61) tmp = c; 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], -8.2e+147], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], -5e+82], c, If[LessEqual[N[(a * b), $MachinePrecision], -2.1e-178], N[(x * y), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 1.16e+61], c, 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 -8.2 \cdot 10^{+147}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq -5 \cdot 10^{+82}:\\
\;\;\;\;c\\
\mathbf{elif}\;a \cdot b \leq -2.1 \cdot 10^{-178}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;a \cdot b \leq 1.16 \cdot 10^{+61}:\\
\;\;\;\;c\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -8.19999999999999932e147 or 1.16e61 < (*.f64 a b) Initial program 96.1%
+-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-*.f6496.1%
Simplified96.1%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6468.9%
Simplified68.9%
if -8.19999999999999932e147 < (*.f64 a b) < -5.00000000000000015e82 or -2.1e-178 < (*.f64 a b) < 1.16e61Initial 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
Simplified46.1%
if -5.00000000000000015e82 < (*.f64 a b) < -2.1e-178Initial 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 x around inf
*-lowering-*.f6446.7%
Simplified46.7%
Final simplification54.7%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (* a b) -4.0)))
(if (<= (* a b) -4e+84)
(+ c t_1)
(if (<= (* a b) -1e-176)
(+ (* x y) (* 0.0625 (* z t)))
(if (<= (* a b) 4e+126) (+ c (* t (* z 0.0625))) (+ (* 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) <= -4e+84) {
tmp = c + t_1;
} else if ((a * b) <= -1e-176) {
tmp = (x * y) + (0.0625 * (z * t));
} else if ((a * b) <= 4e+126) {
tmp = c + (t * (z * 0.0625));
} 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) <= (-4d+84)) then
tmp = c + t_1
else if ((a * b) <= (-1d-176)) then
tmp = (x * y) + (0.0625d0 * (z * t))
else if ((a * b) <= 4d+126) then
tmp = c + (t * (z * 0.0625d0))
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) <= -4e+84) {
tmp = c + t_1;
} else if ((a * b) <= -1e-176) {
tmp = (x * y) + (0.0625 * (z * t));
} else if ((a * b) <= 4e+126) {
tmp = c + (t * (z * 0.0625));
} 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) <= -4e+84: tmp = c + t_1 elif (a * b) <= -1e-176: tmp = (x * y) + (0.0625 * (z * t)) elif (a * b) <= 4e+126: tmp = c + (t * (z * 0.0625)) 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) <= -4e+84) tmp = Float64(c + t_1); elseif (Float64(a * b) <= -1e-176) tmp = Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t))); elseif (Float64(a * b) <= 4e+126) tmp = Float64(c + Float64(t * Float64(z * 0.0625))); 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) <= -4e+84) tmp = c + t_1; elseif ((a * b) <= -1e-176) tmp = (x * y) + (0.0625 * (z * t)); elseif ((a * b) <= 4e+126) tmp = c + (t * (z * 0.0625)); 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], -4e+84], N[(c + t$95$1), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], -1e-176], N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 4e+126], N[(c + N[(t * N[(z * 0.0625), $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 -4 \cdot 10^{+84}:\\
\;\;\;\;c + t\_1\\
\mathbf{elif}\;a \cdot b \leq -1 \cdot 10^{-176}:\\
\;\;\;\;x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;a \cdot b \leq 4 \cdot 10^{+126}:\\
\;\;\;\;c + t \cdot \left(z \cdot 0.0625\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y + t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -4.00000000000000023e84Initial program 98.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-*.f6498.6%
Simplified98.6%
Taylor expanded in c around inf
Simplified79.2%
if -4.00000000000000023e84 < (*.f64 a b) < -1e-176Initial 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-*.f6495.5%
Simplified95.5%
Taylor expanded in c around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.0%
Simplified85.0%
if -1e-176 < (*.f64 a b) < 3.9999999999999997e126Initial 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 a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6494.4%
Simplified94.4%
Taylor expanded in c around inf
Simplified71.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6471.9%
Applied egg-rr71.9%
if 3.9999999999999997e126 < (*.f64 a b) Initial program 93.8%
+-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-*.f6493.8%
Simplified93.8%
Taylor expanded in x around inf
*-lowering-*.f6482.3%
Simplified82.3%
Final simplification77.2%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (/ (* a b) -4.0))))
(if (<= (* a b) -4e+84)
t_1
(if (<= (* a b) -1e-176)
(+ (* x y) (* 0.0625 (* z t)))
(if (<= (* a b) 2e+107) (+ c (* t (* z 0.0625))) 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) <= -4e+84) {
tmp = t_1;
} else if ((a * b) <= -1e-176) {
tmp = (x * y) + (0.0625 * (z * t));
} else if ((a * b) <= 2e+107) {
tmp = c + (t * (z * 0.0625));
} 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) <= (-4d+84)) then
tmp = t_1
else if ((a * b) <= (-1d-176)) then
tmp = (x * y) + (0.0625d0 * (z * t))
else if ((a * b) <= 2d+107) then
tmp = c + (t * (z * 0.0625d0))
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) <= -4e+84) {
tmp = t_1;
} else if ((a * b) <= -1e-176) {
tmp = (x * y) + (0.0625 * (z * t));
} else if ((a * b) <= 2e+107) {
tmp = c + (t * (z * 0.0625));
} 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) <= -4e+84: tmp = t_1 elif (a * b) <= -1e-176: tmp = (x * y) + (0.0625 * (z * t)) elif (a * b) <= 2e+107: tmp = c + (t * (z * 0.0625)) 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) <= -4e+84) tmp = t_1; elseif (Float64(a * b) <= -1e-176) tmp = Float64(Float64(x * y) + Float64(0.0625 * Float64(z * t))); elseif (Float64(a * b) <= 2e+107) tmp = Float64(c + Float64(t * Float64(z * 0.0625))); 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) <= -4e+84) tmp = t_1; elseif ((a * b) <= -1e-176) tmp = (x * y) + (0.0625 * (z * t)); elseif ((a * b) <= 2e+107) tmp = c + (t * (z * 0.0625)); 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], -4e+84], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], -1e-176], N[(N[(x * y), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 2e+107], N[(c + N[(t * N[(z * 0.0625), $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 -4 \cdot 10^{+84}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq -1 \cdot 10^{-176}:\\
\;\;\;\;x \cdot y + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;a \cdot b \leq 2 \cdot 10^{+107}:\\
\;\;\;\;c + t \cdot \left(z \cdot 0.0625\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -4.00000000000000023e84 or 1.9999999999999999e107 < (*.f64 a b) Initial program 96.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-*.f6496.4%
Simplified96.4%
Taylor expanded in c around inf
Simplified79.0%
if -4.00000000000000023e84 < (*.f64 a b) < -1e-176Initial 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-*.f6495.5%
Simplified95.5%
Taylor expanded in c around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6485.0%
Simplified85.0%
if -1e-176 < (*.f64 a b) < 1.9999999999999999e107Initial program 98.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-*.f6498.4%
Simplified98.4%
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-*.f6495.1%
Simplified95.1%
Taylor expanded in c around inf
Simplified71.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.2%
Applied egg-rr72.2%
Final simplification76.8%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ c (/ (* a b) -4.0))))
(if (<= (* a b) -5e+146)
t_1
(if (<= (* a b) -5e-49)
(+ (* x y) c)
(if (<= (* a b) 2e+107) (+ c (* t (* z 0.0625))) 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+146) {
tmp = t_1;
} else if ((a * b) <= -5e-49) {
tmp = (x * y) + c;
} else if ((a * b) <= 2e+107) {
tmp = c + (t * (z * 0.0625));
} 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+146)) then
tmp = t_1
else if ((a * b) <= (-5d-49)) then
tmp = (x * y) + c
else if ((a * b) <= 2d+107) then
tmp = c + (t * (z * 0.0625d0))
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+146) {
tmp = t_1;
} else if ((a * b) <= -5e-49) {
tmp = (x * y) + c;
} else if ((a * b) <= 2e+107) {
tmp = c + (t * (z * 0.0625));
} 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+146: tmp = t_1 elif (a * b) <= -5e-49: tmp = (x * y) + c elif (a * b) <= 2e+107: tmp = c + (t * (z * 0.0625)) 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+146) tmp = t_1; elseif (Float64(a * b) <= -5e-49) tmp = Float64(Float64(x * y) + c); elseif (Float64(a * b) <= 2e+107) tmp = Float64(c + Float64(t * Float64(z * 0.0625))); 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+146) tmp = t_1; elseif ((a * b) <= -5e-49) tmp = (x * y) + c; elseif ((a * b) <= 2e+107) tmp = c + (t * (z * 0.0625)); 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+146], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], -5e-49], N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 2e+107], N[(c + N[(t * N[(z * 0.0625), $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^{+146}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq -5 \cdot 10^{-49}:\\
\;\;\;\;x \cdot y + c\\
\mathbf{elif}\;a \cdot b \leq 2 \cdot 10^{+107}:\\
\;\;\;\;c + t \cdot \left(z \cdot 0.0625\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -4.9999999999999999e146 or 1.9999999999999999e107 < (*.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 c around inf
Simplified82.6%
if -4.9999999999999999e146 < (*.f64 a b) < -4.9999999999999999e-49Initial 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-*.f6489.4%
Simplified89.4%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6470.6%
Simplified70.6%
if -4.9999999999999999e-49 < (*.f64 a b) < 1.9999999999999999e107Initial program 98.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-*.f6498.6%
Simplified98.6%
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-*.f6495.7%
Simplified95.7%
Taylor expanded in c around inf
Simplified72.6%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6473.3%
Applied egg-rr73.3%
Final simplification76.0%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* a b) -5e+150)
(* a (/ b -4.0))
(if (<= (* a b) -5e-49)
(+ (* x y) c)
(if (<= (* a b) 5e+136) (+ c (* t (* z 0.0625))) (* (* a b) -0.25)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((a * b) <= -5e+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= -5e-49) {
tmp = (x * y) + c;
} else if ((a * b) <= 5e+136) {
tmp = c + (t * (z * 0.0625));
} else {
tmp = (a * b) * -0.25;
}
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+150)) then
tmp = a * (b / (-4.0d0))
else if ((a * b) <= (-5d-49)) then
tmp = (x * y) + c
else if ((a * b) <= 5d+136) then
tmp = c + (t * (z * 0.0625d0))
else
tmp = (a * b) * (-0.25d0)
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+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= -5e-49) {
tmp = (x * y) + c;
} else if ((a * b) <= 5e+136) {
tmp = c + (t * (z * 0.0625));
} else {
tmp = (a * b) * -0.25;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (a * b) <= -5e+150: tmp = a * (b / -4.0) elif (a * b) <= -5e-49: tmp = (x * y) + c elif (a * b) <= 5e+136: tmp = c + (t * (z * 0.0625)) else: tmp = (a * b) * -0.25 return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(a * b) <= -5e+150) tmp = Float64(a * Float64(b / -4.0)); elseif (Float64(a * b) <= -5e-49) tmp = Float64(Float64(x * y) + c); elseif (Float64(a * b) <= 5e+136) tmp = Float64(c + Float64(t * Float64(z * 0.0625))); else tmp = Float64(Float64(a * b) * -0.25); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((a * b) <= -5e+150) tmp = a * (b / -4.0); elseif ((a * b) <= -5e-49) tmp = (x * y) + c; elseif ((a * b) <= 5e+136) tmp = c + (t * (z * 0.0625)); else tmp = (a * b) * -0.25; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(a * b), $MachinePrecision], -5e+150], N[(a * N[(b / -4.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], -5e-49], N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e+136], N[(c + N[(t * N[(z * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{+150}:\\
\;\;\;\;a \cdot \frac{b}{-4}\\
\mathbf{elif}\;a \cdot b \leq -5 \cdot 10^{-49}:\\
\;\;\;\;x \cdot y + c\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+136}:\\
\;\;\;\;c + t \cdot \left(z \cdot 0.0625\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000009e150Initial program 97.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-*.f6497.9%
Simplified97.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6482.1%
Simplified82.1%
*-commutativeN/A
metadata-evalN/A
div-invN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6484.2%
Applied egg-rr84.2%
if -5.00000000000000009e150 < (*.f64 a b) < -4.9999999999999999e-49Initial 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-*.f6489.1%
Simplified89.1%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6470.8%
Simplified70.8%
if -4.9999999999999999e-49 < (*.f64 a b) < 5.0000000000000002e136Initial program 98.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-*.f6498.7%
Simplified98.7%
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-*.f6494.4%
Simplified94.4%
Taylor expanded in c around inf
Simplified71.7%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6472.3%
Applied egg-rr72.3%
if 5.0000000000000002e136 < (*.f64 a b) Initial program 93.2%
+-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-*.f6493.2%
Simplified93.2%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6473.9%
Simplified73.9%
Final simplification73.9%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* a b) -5e+150)
(* a (/ b -4.0))
(if (<= (* a b) -5e-49)
(+ (* x y) c)
(if (<= (* a b) 5e+136) (+ c (* 0.0625 (* z t))) (* (* a b) -0.25)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((a * b) <= -5e+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= -5e-49) {
tmp = (x * y) + c;
} else if ((a * b) <= 5e+136) {
tmp = c + (0.0625 * (z * t));
} else {
tmp = (a * b) * -0.25;
}
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+150)) then
tmp = a * (b / (-4.0d0))
else if ((a * b) <= (-5d-49)) then
tmp = (x * y) + c
else if ((a * b) <= 5d+136) then
tmp = c + (0.0625d0 * (z * t))
else
tmp = (a * b) * (-0.25d0)
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+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= -5e-49) {
tmp = (x * y) + c;
} else if ((a * b) <= 5e+136) {
tmp = c + (0.0625 * (z * t));
} else {
tmp = (a * b) * -0.25;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (a * b) <= -5e+150: tmp = a * (b / -4.0) elif (a * b) <= -5e-49: tmp = (x * y) + c elif (a * b) <= 5e+136: tmp = c + (0.0625 * (z * t)) else: tmp = (a * b) * -0.25 return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(a * b) <= -5e+150) tmp = Float64(a * Float64(b / -4.0)); elseif (Float64(a * b) <= -5e-49) tmp = Float64(Float64(x * y) + c); elseif (Float64(a * b) <= 5e+136) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); else tmp = Float64(Float64(a * b) * -0.25); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((a * b) <= -5e+150) tmp = a * (b / -4.0); elseif ((a * b) <= -5e-49) tmp = (x * y) + c; elseif ((a * b) <= 5e+136) tmp = c + (0.0625 * (z * t)); else tmp = (a * b) * -0.25; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(a * b), $MachinePrecision], -5e+150], N[(a * N[(b / -4.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], -5e-49], N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e+136], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{+150}:\\
\;\;\;\;a \cdot \frac{b}{-4}\\
\mathbf{elif}\;a \cdot b \leq -5 \cdot 10^{-49}:\\
\;\;\;\;x \cdot y + c\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+136}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000009e150Initial program 97.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-*.f6497.9%
Simplified97.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6482.1%
Simplified82.1%
*-commutativeN/A
metadata-evalN/A
div-invN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6484.2%
Applied egg-rr84.2%
if -5.00000000000000009e150 < (*.f64 a b) < -4.9999999999999999e-49Initial 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-*.f6489.1%
Simplified89.1%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6470.8%
Simplified70.8%
if -4.9999999999999999e-49 < (*.f64 a b) < 5.0000000000000002e136Initial program 98.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-*.f6498.7%
Simplified98.7%
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-*.f6494.4%
Simplified94.4%
Taylor expanded in c around inf
Simplified71.7%
if 5.0000000000000002e136 < (*.f64 a b) Initial program 93.2%
+-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-*.f6493.2%
Simplified93.2%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6473.9%
Simplified73.9%
Final simplification73.6%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* b (+ (/ (* 0.0625 (* z t)) b) (* a -0.25)))))
(if (<= (* a b) -5e+150)
t_1
(if (<= (* a b) 1e+202) (+ (/ z (/ 16.0 t)) (+ (* x y) c)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = b * (((0.0625 * (z * t)) / b) + (a * -0.25));
double tmp;
if ((a * b) <= -5e+150) {
tmp = t_1;
} else if ((a * b) <= 1e+202) {
tmp = (z / (16.0 / t)) + ((x * y) + c);
} 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 = b * (((0.0625d0 * (z * t)) / b) + (a * (-0.25d0)))
if ((a * b) <= (-5d+150)) then
tmp = t_1
else if ((a * b) <= 1d+202) then
tmp = (z / (16.0d0 / t)) + ((x * y) + 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 t_1 = b * (((0.0625 * (z * t)) / b) + (a * -0.25));
double tmp;
if ((a * b) <= -5e+150) {
tmp = t_1;
} else if ((a * b) <= 1e+202) {
tmp = (z / (16.0 / t)) + ((x * y) + c);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = b * (((0.0625 * (z * t)) / b) + (a * -0.25)) tmp = 0 if (a * b) <= -5e+150: tmp = t_1 elif (a * b) <= 1e+202: tmp = (z / (16.0 / t)) + ((x * y) + c) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(b * Float64(Float64(Float64(0.0625 * Float64(z * t)) / b) + Float64(a * -0.25))) tmp = 0.0 if (Float64(a * b) <= -5e+150) tmp = t_1; elseif (Float64(a * b) <= 1e+202) tmp = Float64(Float64(z / Float64(16.0 / t)) + Float64(Float64(x * y) + c)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = b * (((0.0625 * (z * t)) / b) + (a * -0.25)); tmp = 0.0; if ((a * b) <= -5e+150) tmp = t_1; elseif ((a * b) <= 1e+202) tmp = (z / (16.0 / t)) + ((x * y) + c); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(b * N[(N[(N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision] + N[(a * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5e+150], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 1e+202], N[(N[(z / N[(16.0 / t), $MachinePrecision]), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(\frac{0.0625 \cdot \left(z \cdot t\right)}{b} + a \cdot -0.25\right)\\
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{+150}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 10^{+202}:\\
\;\;\;\;\frac{z}{\frac{16}{t}} + \left(x \cdot y + c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000009e150 or 9.999999999999999e201 < (*.f64 a b) Initial program 94.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-*.f6494.7%
Simplified94.7%
+-commutativeN/A
frac-2negN/A
distribute-frac-negN/A
unsub-negN/A
--lowering--.f64N/A
+-lowering-+.f64N/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
metadata-eval94.7%
Applied egg-rr94.7%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-rgt-neg-inN/A
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
remove-double-negN/A
+-lowering-+.f64N/A
Simplified97.1%
Taylor expanded in t around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6491.8%
Simplified91.8%
if -5.00000000000000009e150 < (*.f64 a b) < 9.999999999999999e201Initial program 99.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-*.f6499.0%
Simplified99.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-*.f6491.5%
Simplified91.5%
associate-*r*N/A
fma-defineN/A
metadata-evalN/A
associate-/r/N/A
fma-defineN/A
associate-/r/N/A
clear-numN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6491.9%
Applied egg-rr91.9%
Final simplification91.9%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (* a b) -4.0)))
(if (<= (* a b) -5e+150)
(+ (* 0.0625 (* z t)) t_1)
(if (<= (* a b) 5e+136)
(+ (/ z (/ 16.0 t)) (+ (* x y) c))
(+ (* 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+150) {
tmp = (0.0625 * (z * t)) + t_1;
} else if ((a * b) <= 5e+136) {
tmp = (z / (16.0 / t)) + ((x * y) + c);
} 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+150)) then
tmp = (0.0625d0 * (z * t)) + t_1
else if ((a * b) <= 5d+136) then
tmp = (z / (16.0d0 / t)) + ((x * y) + c)
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+150) {
tmp = (0.0625 * (z * t)) + t_1;
} else if ((a * b) <= 5e+136) {
tmp = (z / (16.0 / t)) + ((x * y) + c);
} 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+150: tmp = (0.0625 * (z * t)) + t_1 elif (a * b) <= 5e+136: tmp = (z / (16.0 / t)) + ((x * y) + c) 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+150) tmp = Float64(Float64(0.0625 * Float64(z * t)) + t_1); elseif (Float64(a * b) <= 5e+136) tmp = Float64(Float64(z / Float64(16.0 / t)) + Float64(Float64(x * y) + c)); 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+150) tmp = (0.0625 * (z * t)) + t_1; elseif ((a * b) <= 5e+136) tmp = (z / (16.0 / t)) + ((x * y) + c); 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+150], N[(N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e+136], N[(N[(z / N[(16.0 / t), $MachinePrecision]), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] + c), $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^{+150}:\\
\;\;\;\;0.0625 \cdot \left(z \cdot t\right) + t\_1\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+136}:\\
\;\;\;\;\frac{z}{\frac{16}{t}} + \left(x \cdot y + c\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y + t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000009e150Initial program 97.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-*.f6497.9%
Simplified97.9%
Taylor expanded in z around inf
*-lowering-*.f64N/A
*-lowering-*.f6489.7%
Simplified89.7%
if -5.00000000000000009e150 < (*.f64 a b) < 5.0000000000000002e136Initial program 99.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-*.f6499.0%
Simplified99.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-*.f6493.2%
Simplified93.2%
associate-*r*N/A
fma-defineN/A
metadata-evalN/A
associate-/r/N/A
fma-defineN/A
associate-/r/N/A
clear-numN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6493.6%
Applied egg-rr93.6%
if 5.0000000000000002e136 < (*.f64 a b) Initial program 93.2%
+-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-*.f6493.2%
Simplified93.2%
Taylor expanded in x around inf
*-lowering-*.f6483.0%
Simplified83.0%
Final simplification91.3%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (* a b) -4.0)))
(if (<= (* a b) -5e+146)
(+ c t_1)
(if (<= (* a b) 5e+136)
(+ (/ z (/ 16.0 t)) (+ (* x y) c))
(+ (* 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+146) {
tmp = c + t_1;
} else if ((a * b) <= 5e+136) {
tmp = (z / (16.0 / t)) + ((x * y) + c);
} 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+146)) then
tmp = c + t_1
else if ((a * b) <= 5d+136) then
tmp = (z / (16.0d0 / t)) + ((x * y) + c)
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+146) {
tmp = c + t_1;
} else if ((a * b) <= 5e+136) {
tmp = (z / (16.0 / t)) + ((x * y) + c);
} 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+146: tmp = c + t_1 elif (a * b) <= 5e+136: tmp = (z / (16.0 / t)) + ((x * y) + c) 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+146) tmp = Float64(c + t_1); elseif (Float64(a * b) <= 5e+136) tmp = Float64(Float64(z / Float64(16.0 / t)) + Float64(Float64(x * y) + c)); 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+146) tmp = c + t_1; elseif ((a * b) <= 5e+136) tmp = (z / (16.0 / t)) + ((x * y) + c); 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+146], N[(c + t$95$1), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e+136], N[(N[(z / N[(16.0 / t), $MachinePrecision]), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] + c), $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^{+146}:\\
\;\;\;\;c + t\_1\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+136}:\\
\;\;\;\;\frac{z}{\frac{16}{t}} + \left(x \cdot y + c\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y + t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -4.9999999999999999e146Initial program 97.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-*.f6497.9%
Simplified97.9%
Taylor expanded in c around inf
Simplified87.8%
if -4.9999999999999999e146 < (*.f64 a b) < 5.0000000000000002e136Initial program 99.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-*.f6499.0%
Simplified99.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-*.f6493.3%
Simplified93.3%
associate-*r*N/A
fma-defineN/A
metadata-evalN/A
associate-/r/N/A
fma-defineN/A
associate-/r/N/A
clear-numN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6493.7%
Applied egg-rr93.7%
if 5.0000000000000002e136 < (*.f64 a b) Initial program 93.2%
+-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-*.f6493.2%
Simplified93.2%
Taylor expanded in x around inf
*-lowering-*.f6483.0%
Simplified83.0%
Final simplification91.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (* a b) -4.0)))
(if (<= (* a b) -5e+146)
(+ c t_1)
(if (<= (* a b) 5e+136)
(+ (* 0.0625 (* z t)) (+ (* x y) c))
(+ (* 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+146) {
tmp = c + t_1;
} else if ((a * b) <= 5e+136) {
tmp = (0.0625 * (z * t)) + ((x * y) + c);
} 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+146)) then
tmp = c + t_1
else if ((a * b) <= 5d+136) then
tmp = (0.0625d0 * (z * t)) + ((x * y) + c)
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+146) {
tmp = c + t_1;
} else if ((a * b) <= 5e+136) {
tmp = (0.0625 * (z * t)) + ((x * y) + c);
} 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+146: tmp = c + t_1 elif (a * b) <= 5e+136: tmp = (0.0625 * (z * t)) + ((x * y) + c) 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+146) tmp = Float64(c + t_1); elseif (Float64(a * b) <= 5e+136) tmp = Float64(Float64(0.0625 * Float64(z * t)) + Float64(Float64(x * y) + c)); 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+146) tmp = c + t_1; elseif ((a * b) <= 5e+136) tmp = (0.0625 * (z * t)) + ((x * y) + c); 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+146], N[(c + t$95$1), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e+136], N[(N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision] + N[(N[(x * y), $MachinePrecision] + c), $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^{+146}:\\
\;\;\;\;c + t\_1\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+136}:\\
\;\;\;\;0.0625 \cdot \left(z \cdot t\right) + \left(x \cdot y + c\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot y + t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -4.9999999999999999e146Initial program 97.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-*.f6497.9%
Simplified97.9%
Taylor expanded in c around inf
Simplified87.8%
if -4.9999999999999999e146 < (*.f64 a b) < 5.0000000000000002e136Initial program 99.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-*.f6499.0%
Simplified99.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-*.f6493.3%
Simplified93.3%
if 5.0000000000000002e136 < (*.f64 a b) Initial program 93.2%
+-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-*.f6493.2%
Simplified93.2%
Taylor expanded in x around inf
*-lowering-*.f6483.0%
Simplified83.0%
Final simplification90.8%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* a b) -5e+150) (* a (/ b -4.0)) (if (<= (* a b) 5e+136) (+ (* x y) c) (* (* a b) -0.25))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((a * b) <= -5e+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= 5e+136) {
tmp = (x * y) + c;
} else {
tmp = (a * b) * -0.25;
}
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+150)) then
tmp = a * (b / (-4.0d0))
else if ((a * b) <= 5d+136) then
tmp = (x * y) + c
else
tmp = (a * b) * (-0.25d0)
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+150) {
tmp = a * (b / -4.0);
} else if ((a * b) <= 5e+136) {
tmp = (x * y) + c;
} else {
tmp = (a * b) * -0.25;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (a * b) <= -5e+150: tmp = a * (b / -4.0) elif (a * b) <= 5e+136: tmp = (x * y) + c else: tmp = (a * b) * -0.25 return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(a * b) <= -5e+150) tmp = Float64(a * Float64(b / -4.0)); elseif (Float64(a * b) <= 5e+136) tmp = Float64(Float64(x * y) + c); else tmp = Float64(Float64(a * b) * -0.25); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) tmp = 0.0; if ((a * b) <= -5e+150) tmp = a * (b / -4.0); elseif ((a * b) <= 5e+136) tmp = (x * y) + c; else tmp = (a * b) * -0.25; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(a * b), $MachinePrecision], -5e+150], N[(a * N[(b / -4.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a * b), $MachinePrecision], 5e+136], N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{+150}:\\
\;\;\;\;a \cdot \frac{b}{-4}\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+136}:\\
\;\;\;\;x \cdot y + c\\
\mathbf{else}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\end{array}
\end{array}
if (*.f64 a b) < -5.00000000000000009e150Initial program 97.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-*.f6497.9%
Simplified97.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6482.1%
Simplified82.1%
*-commutativeN/A
metadata-evalN/A
div-invN/A
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f6484.2%
Applied egg-rr84.2%
if -5.00000000000000009e150 < (*.f64 a b) < 5.0000000000000002e136Initial program 99.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-*.f6499.0%
Simplified99.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-*.f6493.2%
Simplified93.2%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6465.8%
Simplified65.8%
if 5.0000000000000002e136 < (*.f64 a b) Initial program 93.2%
+-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-*.f6493.2%
Simplified93.2%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6473.9%
Simplified73.9%
Final simplification69.7%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* x y) -1.4e+28) (* x y) (if (<= (* x y) 2.05e+211) c (* x y))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -1.4e+28) {
tmp = x * y;
} else if ((x * y) <= 2.05e+211) {
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) <= (-1.4d+28)) then
tmp = x * y
else if ((x * y) <= 2.05d+211) 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) <= -1.4e+28) {
tmp = x * y;
} else if ((x * y) <= 2.05e+211) {
tmp = c;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (x * y) <= -1.4e+28: tmp = x * y elif (x * y) <= 2.05e+211: tmp = c else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -1.4e+28) tmp = Float64(x * y); elseif (Float64(x * y) <= 2.05e+211) 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) <= -1.4e+28) tmp = x * y; elseif ((x * y) <= 2.05e+211) 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], -1.4e+28], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 2.05e+211], c, N[(x * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -1.4 \cdot 10^{+28}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq 2.05 \cdot 10^{+211}:\\
\;\;\;\;c\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -1.4000000000000001e28 or 2.0499999999999999e211 < (*.f64 x y) Initial program 95.2%
+-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.2%
Simplified95.2%
Taylor expanded in x around inf
*-lowering-*.f6464.7%
Simplified64.7%
if -1.4000000000000001e28 < (*.f64 x y) < 2.0499999999999999e211Initial program 99.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-*.f6499.0%
Simplified99.0%
Taylor expanded in c around inf
Simplified37.0%
(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 97.8%
+-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.8%
Simplified97.8%
associate-/l*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f6498.0%
Applied egg-rr98.0%
(FPCore (x y z t a b c) :precision binary64 (+ c (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return c + (((x * y) + ((z * t) / 16.0)) - ((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 + (((x * y) + ((z * t) / 16.0d0)) - ((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 + (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0));
}
def code(x, y, z, t, a, b, c): return c + (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0))
function code(x, y, z, t, a, b, c) return Float64(c + Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0))) end
function tmp = code(x, y, z, t, a, b, c) tmp = c + (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)); end
code[x_, y_, z_, t_, a_, b_, c_] := N[(c + N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
c + \left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right)
\end{array}
Initial program 97.8%
Final simplification97.8%
(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 97.8%
+-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.8%
Simplified97.8%
Taylor expanded in c around inf
Simplified28.0%
herbie shell --seed 2024160
(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))