
(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 11 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 (+ (- (+ (* 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}
Initial program 98.4%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* x y) -3.235e+74)
(* x y)
(if (<= (* x y) -5.4e-150)
(* 0.0625 (* z t))
(if (<= (* x y) -8.2e-286)
c
(if (<= (* x y) 4.6e+123) (* (* 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) <= -3.235e+74) {
tmp = x * y;
} else if ((x * y) <= -5.4e-150) {
tmp = 0.0625 * (z * t);
} else if ((x * y) <= -8.2e-286) {
tmp = c;
} else if ((x * y) <= 4.6e+123) {
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) <= (-3.235d+74)) then
tmp = x * y
else if ((x * y) <= (-5.4d-150)) then
tmp = 0.0625d0 * (z * t)
else if ((x * y) <= (-8.2d-286)) then
tmp = c
else if ((x * y) <= 4.6d+123) 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) <= -3.235e+74) {
tmp = x * y;
} else if ((x * y) <= -5.4e-150) {
tmp = 0.0625 * (z * t);
} else if ((x * y) <= -8.2e-286) {
tmp = c;
} else if ((x * y) <= 4.6e+123) {
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) <= -3.235e+74: tmp = x * y elif (x * y) <= -5.4e-150: tmp = 0.0625 * (z * t) elif (x * y) <= -8.2e-286: tmp = c elif (x * y) <= 4.6e+123: 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) <= -3.235e+74) tmp = Float64(x * y); elseif (Float64(x * y) <= -5.4e-150) tmp = Float64(0.0625 * Float64(z * t)); elseif (Float64(x * y) <= -8.2e-286) tmp = c; elseif (Float64(x * y) <= 4.6e+123) 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) <= -3.235e+74) tmp = x * y; elseif ((x * y) <= -5.4e-150) tmp = 0.0625 * (z * t); elseif ((x * y) <= -8.2e-286) tmp = c; elseif ((x * y) <= 4.6e+123) 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], -3.235e+74], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], -5.4e-150], N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], -8.2e-286], c, If[LessEqual[N[(x * y), $MachinePrecision], 4.6e+123], N[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision], N[(x * y), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -3.235 \cdot 10^{+74}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq -5.4 \cdot 10^{-150}:\\
\;\;\;\;0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;x \cdot y \leq -8.2 \cdot 10^{-286}:\\
\;\;\;\;c\\
\mathbf{elif}\;x \cdot y \leq 4.6 \cdot 10^{+123}:\\
\;\;\;\;\left(a \cdot b\right) \cdot -0.25\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -3.2350000000000001e74 or 4.59999999999999981e123 < (*.f64 x y) Initial program 96.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-*.f6496.9%
Simplified96.9%
Taylor expanded in x around inf
*-lowering-*.f6466.8%
Simplified66.8%
if -3.2350000000000001e74 < (*.f64 x y) < -5.4000000000000003e-150Initial 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-*.f6447.7%
Simplified47.7%
if -5.4000000000000003e-150 < (*.f64 x y) < -8.2e-286Initial 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 c around inf
Simplified58.4%
if -8.2e-286 < (*.f64 x y) < 4.59999999999999981e123Initial 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 a around inf
*-lowering-*.f64N/A
*-lowering-*.f6443.2%
Simplified43.2%
Final simplification54.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (/ (* a b) -4.0)))
(if (<= (* x y) -6.5e+131)
(+ (* x y) t_1)
(if (<= (* x y) -1.55e-300)
(+ c (* 0.0625 (* z t)))
(if (<= (* x y) 2.6e+107) (+ c t_1) (+ (* x y) (* z (* t 0.0625))))))))
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 ((x * y) <= -6.5e+131) {
tmp = (x * y) + t_1;
} else if ((x * y) <= -1.55e-300) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 2.6e+107) {
tmp = c + t_1;
} else {
tmp = (x * y) + (z * (t * 0.0625));
}
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 ((x * y) <= (-6.5d+131)) then
tmp = (x * y) + t_1
else if ((x * y) <= (-1.55d-300)) then
tmp = c + (0.0625d0 * (z * t))
else if ((x * y) <= 2.6d+107) then
tmp = c + t_1
else
tmp = (x * y) + (z * (t * 0.0625d0))
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 ((x * y) <= -6.5e+131) {
tmp = (x * y) + t_1;
} else if ((x * y) <= -1.55e-300) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 2.6e+107) {
tmp = c + t_1;
} else {
tmp = (x * y) + (z * (t * 0.0625));
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (a * b) / -4.0 tmp = 0 if (x * y) <= -6.5e+131: tmp = (x * y) + t_1 elif (x * y) <= -1.55e-300: tmp = c + (0.0625 * (z * t)) elif (x * y) <= 2.6e+107: tmp = c + t_1 else: tmp = (x * y) + (z * (t * 0.0625)) return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(a * b) / -4.0) tmp = 0.0 if (Float64(x * y) <= -6.5e+131) tmp = Float64(Float64(x * y) + t_1); elseif (Float64(x * y) <= -1.55e-300) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); elseif (Float64(x * y) <= 2.6e+107) tmp = Float64(c + t_1); else tmp = Float64(Float64(x * y) + Float64(z * Float64(t * 0.0625))); 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 ((x * y) <= -6.5e+131) tmp = (x * y) + t_1; elseif ((x * y) <= -1.55e-300) tmp = c + (0.0625 * (z * t)); elseif ((x * y) <= 2.6e+107) tmp = c + t_1; else tmp = (x * y) + (z * (t * 0.0625)); 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[(x * y), $MachinePrecision], -6.5e+131], N[(N[(x * y), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], -1.55e-300], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 2.6e+107], N[(c + t$95$1), $MachinePrecision], N[(N[(x * y), $MachinePrecision] + N[(z * N[(t * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{a \cdot b}{-4}\\
\mathbf{if}\;x \cdot y \leq -6.5 \cdot 10^{+131}:\\
\;\;\;\;x \cdot y + t\_1\\
\mathbf{elif}\;x \cdot y \leq -1.55 \cdot 10^{-300}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;x \cdot y \leq 2.6 \cdot 10^{+107}:\\
\;\;\;\;c + t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot y + z \cdot \left(t \cdot 0.0625\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -6.5e131Initial 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-*.f6485.7%
Simplified85.7%
if -6.5e131 < (*.f64 x y) < -1.5500000000000001e-300Initial 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-*.f6477.7%
Simplified77.7%
Taylor expanded in c around inf
Simplified67.8%
if -1.5500000000000001e-300 < (*.f64 x y) < 2.6000000000000001e107Initial 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 c around inf
Simplified70.8%
if 2.6000000000000001e107 < (*.f64 x y) Initial program 95.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-*.f6495.9%
Simplified95.9%
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.0%
Simplified91.0%
Taylor expanded in c around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6489.1%
Simplified89.1%
Final simplification75.6%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ (* x y) (* z (* t 0.0625)))))
(if (<= (* x y) -2.6e+131)
t_1
(if (<= (* x y) -6.6e-302)
(+ c (* 0.0625 (* z t)))
(if (<= (* x y) 7.5e+104) (+ c (/ (* a b) -4.0)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * y) + (z * (t * 0.0625));
double tmp;
if ((x * y) <= -2.6e+131) {
tmp = t_1;
} else if ((x * y) <= -6.6e-302) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 7.5e+104) {
tmp = c + ((a * b) / -4.0);
} 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 = (x * y) + (z * (t * 0.0625d0))
if ((x * y) <= (-2.6d+131)) then
tmp = t_1
else if ((x * y) <= (-6.6d-302)) then
tmp = c + (0.0625d0 * (z * t))
else if ((x * y) <= 7.5d+104) then
tmp = c + ((a * b) / (-4.0d0))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * y) + (z * (t * 0.0625));
double tmp;
if ((x * y) <= -2.6e+131) {
tmp = t_1;
} else if ((x * y) <= -6.6e-302) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 7.5e+104) {
tmp = c + ((a * b) / -4.0);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (x * y) + (z * (t * 0.0625)) tmp = 0 if (x * y) <= -2.6e+131: tmp = t_1 elif (x * y) <= -6.6e-302: tmp = c + (0.0625 * (z * t)) elif (x * y) <= 7.5e+104: tmp = c + ((a * b) / -4.0) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * y) + Float64(z * Float64(t * 0.0625))) tmp = 0.0 if (Float64(x * y) <= -2.6e+131) tmp = t_1; elseif (Float64(x * y) <= -6.6e-302) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); elseif (Float64(x * y) <= 7.5e+104) tmp = Float64(c + Float64(Float64(a * b) / -4.0)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (x * y) + (z * (t * 0.0625)); tmp = 0.0; if ((x * y) <= -2.6e+131) tmp = t_1; elseif ((x * y) <= -6.6e-302) tmp = c + (0.0625 * (z * t)); elseif ((x * y) <= 7.5e+104) tmp = c + ((a * b) / -4.0); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] + N[(z * N[(t * 0.0625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2.6e+131], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -6.6e-302], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 7.5e+104], N[(c + N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot y + z \cdot \left(t \cdot 0.0625\right)\\
\mathbf{if}\;x \cdot y \leq -2.6 \cdot 10^{+131}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq -6.6 \cdot 10^{-302}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;x \cdot y \leq 7.5 \cdot 10^{+104}:\\
\;\;\;\;c + \frac{a \cdot b}{-4}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -2.6e131 or 7.5000000000000002e104 < (*.f64 x y) Initial program 96.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-*.f6496.6%
Simplified96.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-*.f6487.0%
Simplified87.0%
Taylor expanded in c around 0
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6485.1%
Simplified85.1%
if -2.6e131 < (*.f64 x y) < -6.6000000000000005e-302Initial 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-*.f6477.7%
Simplified77.7%
Taylor expanded in c around inf
Simplified67.8%
if -6.6000000000000005e-302 < (*.f64 x y) < 7.5000000000000002e104Initial 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 c around inf
Simplified70.8%
Final simplification74.7%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ (* x y) c)))
(if (<= (* x y) -2.2e+123)
t_1
(if (<= (* x y) -7.2e-300)
(+ c (* 0.0625 (* z t)))
(if (<= (* x y) 3.6e+108) (+ c (/ (* a b) -4.0)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * y) + c;
double tmp;
if ((x * y) <= -2.2e+123) {
tmp = t_1;
} else if ((x * y) <= -7.2e-300) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 3.6e+108) {
tmp = c + ((a * b) / -4.0);
} 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 = (x * y) + c
if ((x * y) <= (-2.2d+123)) then
tmp = t_1
else if ((x * y) <= (-7.2d-300)) then
tmp = c + (0.0625d0 * (z * t))
else if ((x * y) <= 3.6d+108) then
tmp = c + ((a * b) / (-4.0d0))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = (x * y) + c;
double tmp;
if ((x * y) <= -2.2e+123) {
tmp = t_1;
} else if ((x * y) <= -7.2e-300) {
tmp = c + (0.0625 * (z * t));
} else if ((x * y) <= 3.6e+108) {
tmp = c + ((a * b) / -4.0);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (x * y) + c tmp = 0 if (x * y) <= -2.2e+123: tmp = t_1 elif (x * y) <= -7.2e-300: tmp = c + (0.0625 * (z * t)) elif (x * y) <= 3.6e+108: tmp = c + ((a * b) / -4.0) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * y) + c) tmp = 0.0 if (Float64(x * y) <= -2.2e+123) tmp = t_1; elseif (Float64(x * y) <= -7.2e-300) tmp = Float64(c + Float64(0.0625 * Float64(z * t))); elseif (Float64(x * y) <= 3.6e+108) tmp = Float64(c + Float64(Float64(a * b) / -4.0)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c) t_1 = (x * y) + c; tmp = 0.0; if ((x * y) <= -2.2e+123) tmp = t_1; elseif ((x * y) <= -7.2e-300) tmp = c + (0.0625 * (z * t)); elseif ((x * y) <= 3.6e+108) tmp = c + ((a * b) / -4.0); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2.2e+123], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], -7.2e-300], N[(c + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 3.6e+108], N[(c + N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot y + c\\
\mathbf{if}\;x \cdot y \leq -2.2 \cdot 10^{+123}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq -7.2 \cdot 10^{-300}:\\
\;\;\;\;c + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{elif}\;x \cdot y \leq 3.6 \cdot 10^{+108}:\\
\;\;\;\;c + \frac{a \cdot b}{-4}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -2.19999999999999992e123 or 3.6e108 < (*.f64 x y) Initial program 96.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-*.f6496.6%
Simplified96.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-*.f6487.3%
Simplified87.3%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6474.3%
Simplified74.3%
if -2.19999999999999992e123 < (*.f64 x y) < -7.20000000000000031e-300Initial 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-*.f6477.1%
Simplified77.1%
Taylor expanded in c around inf
Simplified68.2%
if -7.20000000000000031e-300 < (*.f64 x y) < 3.6e108Initial 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 c around inf
Simplified70.8%
Final simplification71.2%
(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+166)
t_2
(if (<= (* a b) 5e+43) (+ 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+166) {
tmp = t_2;
} else if ((a * b) <= 5e+43) {
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+166)) then
tmp = t_2
else if ((a * b) <= 5d+43) 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+166) {
tmp = t_2;
} else if ((a * b) <= 5e+43) {
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+166: tmp = t_2 elif (a * b) <= 5e+43: 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+166) tmp = t_2; elseif (Float64(a * b) <= 5e+43) 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+166) tmp = t_2; elseif ((a * b) <= 5e+43) 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+166], t$95$2, If[LessEqual[N[(a * b), $MachinePrecision], 5e+43], 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^{+166}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+43}:\\
\;\;\;\;t\_1 + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 a b) < -5.0000000000000002e166 or 5.0000000000000004e43 < (*.f64 a b) Initial 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 0
+-lowering-+.f64N/A
*-lowering-*.f6486.1%
Simplified86.1%
if -5.0000000000000002e166 < (*.f64 a b) < 5.0000000000000004e43Initial program 98.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-*.f6498.8%
Simplified98.8%
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.2%
Simplified94.2%
Final simplification91.2%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (+ (* x y) (/ (* a b) -4.0))))
(if (<= (* a b) -5e+166)
t_1
(if (<= (* a b) 5e+43) (+ (+ (* x y) 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 = (x * y) + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5e+166) {
tmp = t_1;
} else if ((a * b) <= 5e+43) {
tmp = ((x * y) + 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 = (x * y) + ((a * b) / (-4.0d0))
if ((a * b) <= (-5d+166)) then
tmp = t_1
else if ((a * b) <= 5d+43) then
tmp = ((x * y) + 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 = (x * y) + ((a * b) / -4.0);
double tmp;
if ((a * b) <= -5e+166) {
tmp = t_1;
} else if ((a * b) <= 5e+43) {
tmp = ((x * y) + c) + (0.0625 * (z * t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c): t_1 = (x * y) + ((a * b) / -4.0) tmp = 0 if (a * b) <= -5e+166: tmp = t_1 elif (a * b) <= 5e+43: tmp = ((x * y) + c) + (0.0625 * (z * t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c) t_1 = Float64(Float64(x * y) + Float64(Float64(a * b) / -4.0)) tmp = 0.0 if (Float64(a * b) <= -5e+166) tmp = t_1; elseif (Float64(a * b) <= 5e+43) tmp = Float64(Float64(Float64(x * y) + 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 = (x * y) + ((a * b) / -4.0); tmp = 0.0; if ((a * b) <= -5e+166) tmp = t_1; elseif ((a * b) <= 5e+43) tmp = ((x * y) + 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[(N[(x * y), $MachinePrecision] + N[(N[(a * b), $MachinePrecision] / -4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -5e+166], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 5e+43], N[(N[(N[(x * y), $MachinePrecision] + c), $MachinePrecision] + N[(0.0625 * N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot y + \frac{a \cdot b}{-4}\\
\mathbf{if}\;a \cdot b \leq -5 \cdot 10^{+166}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 5 \cdot 10^{+43}:\\
\;\;\;\;\left(x \cdot y + c\right) + 0.0625 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -5.0000000000000002e166 or 5.0000000000000004e43 < (*.f64 a b) Initial 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 x around inf
*-lowering-*.f6482.4%
Simplified82.4%
if -5.0000000000000002e166 < (*.f64 a b) < 5.0000000000000004e43Initial program 98.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-*.f6498.8%
Simplified98.8%
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.2%
Simplified94.2%
Final simplification89.9%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (* (* a b) -0.25)))
(if (<= (* a b) -2.15e+163)
t_1
(if (<= (* a b) 4.8e+242) (+ (* x y) 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) <= -2.15e+163) {
tmp = t_1;
} else if ((a * b) <= 4.8e+242) {
tmp = (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 = (a * b) * (-0.25d0)
if ((a * b) <= (-2.15d+163)) then
tmp = t_1
else if ((a * b) <= 4.8d+242) then
tmp = (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 = (a * b) * -0.25;
double tmp;
if ((a * b) <= -2.15e+163) {
tmp = t_1;
} else if ((a * b) <= 4.8e+242) {
tmp = (x * y) + 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) <= -2.15e+163: tmp = t_1 elif (a * b) <= 4.8e+242: tmp = (x * y) + 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) <= -2.15e+163) tmp = t_1; elseif (Float64(a * b) <= 4.8e+242) tmp = 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 = (a * b) * -0.25; tmp = 0.0; if ((a * b) <= -2.15e+163) tmp = t_1; elseif ((a * b) <= 4.8e+242) tmp = (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[(N[(a * b), $MachinePrecision] * -0.25), $MachinePrecision]}, If[LessEqual[N[(a * b), $MachinePrecision], -2.15e+163], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 4.8e+242], N[(N[(x * y), $MachinePrecision] + c), $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 -2.15 \cdot 10^{+163}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 4.8 \cdot 10^{+242}:\\
\;\;\;\;x \cdot y + c\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -2.1500000000000001e163 or 4.80000000000000024e242 < (*.f64 a b) Initial program 97.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-*.f6497.1%
Simplified97.1%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6480.6%
Simplified80.6%
if -2.1500000000000001e163 < (*.f64 a b) < 4.80000000000000024e242Initial 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 a around 0
+-commutativeN/A
associate-+l+N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6490.6%
Simplified90.6%
Taylor expanded in t around 0
+-lowering-+.f64N/A
*-lowering-*.f6462.6%
Simplified62.6%
Final simplification67.4%
(FPCore (x y z t a b c) :precision binary64 (let* ((t_1 (* (* a b) -0.25))) (if (<= (* a b) -1.75e+142) t_1 (if (<= (* a b) 4.8e+242) (* 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) * -0.25;
double tmp;
if ((a * b) <= -1.75e+142) {
tmp = t_1;
} else if ((a * b) <= 4.8e+242) {
tmp = x * y;
} 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) <= (-1.75d+142)) then
tmp = t_1
else if ((a * b) <= 4.8d+242) then
tmp = x * y
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) <= -1.75e+142) {
tmp = t_1;
} else if ((a * b) <= 4.8e+242) {
tmp = x * y;
} 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) <= -1.75e+142: tmp = t_1 elif (a * b) <= 4.8e+242: tmp = x * y 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) <= -1.75e+142) tmp = t_1; elseif (Float64(a * b) <= 4.8e+242) tmp = Float64(x * y); 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) <= -1.75e+142) tmp = t_1; elseif ((a * b) <= 4.8e+242) tmp = x * y; 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], -1.75e+142], t$95$1, If[LessEqual[N[(a * b), $MachinePrecision], 4.8e+242], N[(x * y), $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 -1.75 \cdot 10^{+142}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \cdot b \leq 4.8 \cdot 10^{+242}:\\
\;\;\;\;x \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 a b) < -1.74999999999999999e142 or 4.80000000000000024e242 < (*.f64 a b) Initial program 97.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-*.f6497.2%
Simplified97.2%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6477.3%
Simplified77.3%
if -1.74999999999999999e142 < (*.f64 a b) < 4.80000000000000024e242Initial 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-*.f6438.4%
Simplified38.4%
Final simplification49.2%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* x y) -2.6e+132) (* x y) (if (<= (* x y) 4.5e+104) c (* x y))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -2.6e+132) {
tmp = x * y;
} else if ((x * y) <= 4.5e+104) {
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) <= (-2.6d+132)) then
tmp = x * y
else if ((x * y) <= 4.5d+104) 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) <= -2.6e+132) {
tmp = x * y;
} else if ((x * y) <= 4.5e+104) {
tmp = c;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y, z, t, a, b, c): tmp = 0 if (x * y) <= -2.6e+132: tmp = x * y elif (x * y) <= 4.5e+104: tmp = c else: tmp = x * y return tmp
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -2.6e+132) tmp = Float64(x * y); elseif (Float64(x * y) <= 4.5e+104) 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) <= -2.6e+132) tmp = x * y; elseif ((x * y) <= 4.5e+104) 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], -2.6e+132], N[(x * y), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 4.5e+104], c, N[(x * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -2.6 \cdot 10^{+132}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \cdot y \leq 4.5 \cdot 10^{+104}:\\
\;\;\;\;c\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if (*.f64 x y) < -2.6e132 or 4.4999999999999998e104 < (*.f64 x y) Initial program 96.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-*.f6496.6%
Simplified96.6%
Taylor expanded in x around inf
*-lowering-*.f6471.7%
Simplified71.7%
if -2.6e132 < (*.f64 x y) < 4.4999999999999998e104Initial program 99.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-*.f6499.4%
Simplified99.4%
Taylor expanded in c around inf
Simplified29.4%
(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.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 c around inf
Simplified20.8%
herbie shell --seed 2024138
(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))