
(FPCore (x y z t a b) :precision binary64 (+ (+ (+ x (* y z)) (* t a)) (* (* a z) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x + (y * z)) + (t * a)) + ((a * z) * b);
}
real(8) function code(x, y, z, t, a, b)
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
code = ((x + (y * z)) + (t * a)) + ((a * z) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x + (y * z)) + (t * a)) + ((a * z) * b);
}
def code(x, y, z, t, a, b): return ((x + (y * z)) + (t * a)) + ((a * z) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x + Float64(y * z)) + Float64(t * a)) + Float64(Float64(a * z) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x + (y * z)) + (t * a)) + ((a * z) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x + N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(t * a), $MachinePrecision]), $MachinePrecision] + N[(N[(a * z), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x + y \cdot z\right) + t \cdot a\right) + \left(a \cdot z\right) \cdot b
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (+ (+ (+ x (* y z)) (* t a)) (* (* a z) b)))
double code(double x, double y, double z, double t, double a, double b) {
return ((x + (y * z)) + (t * a)) + ((a * z) * b);
}
real(8) function code(x, y, z, t, a, b)
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
code = ((x + (y * z)) + (t * a)) + ((a * z) * b)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((x + (y * z)) + (t * a)) + ((a * z) * b);
}
def code(x, y, z, t, a, b): return ((x + (y * z)) + (t * a)) + ((a * z) * b)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(x + Float64(y * z)) + Float64(t * a)) + Float64(Float64(a * z) * b)) end
function tmp = code(x, y, z, t, a, b) tmp = ((x + (y * z)) + (t * a)) + ((a * z) * b); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(x + N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(t * a), $MachinePrecision]), $MachinePrecision] + N[(N[(a * z), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x + y \cdot z\right) + t \cdot a\right) + \left(a \cdot z\right) \cdot b
\end{array}
(FPCore (x y z t a b) :precision binary64 (if (<= z -20.0) (fma z (fma a b y) (fma t a x)) (fma y z (fma a (fma z b t) x))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (z <= -20.0) {
tmp = fma(z, fma(a, b, y), fma(t, a, x));
} else {
tmp = fma(y, z, fma(a, fma(z, b, t), x));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (z <= -20.0) tmp = fma(z, fma(a, b, y), fma(t, a, x)); else tmp = fma(y, z, fma(a, fma(z, b, t), x)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[z, -20.0], N[(z * N[(a * b + y), $MachinePrecision] + N[(t * a + x), $MachinePrecision]), $MachinePrecision], N[(y * z + N[(a * N[(z * b + t), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -20:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(a, b, y\right), \mathsf{fma}\left(t, a, x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, z, \mathsf{fma}\left(a, \mathsf{fma}\left(z, b, t\right), x\right)\right)\\
\end{array}
\end{array}
if z < -20Initial program 74.8%
+-commutative74.8%
+-commutative74.8%
associate-+l+74.8%
associate-+r+74.8%
*-commutative74.8%
associate-*l*85.5%
*-commutative85.5%
distribute-lft-out93.5%
fma-def98.4%
fma-def98.4%
+-commutative98.4%
fma-def98.4%
Simplified98.4%
if -20 < z Initial program 95.3%
associate-+l+95.3%
+-commutative95.3%
associate-+l+95.3%
fma-def95.8%
+-commutative95.8%
*-commutative95.8%
associate-*l*95.3%
distribute-lft-out97.9%
fma-def97.9%
+-commutative97.9%
fma-def97.9%
Simplified97.9%
Final simplification98.0%
(FPCore (x y z t a b) :precision binary64 (fma y z (fma a (fma z b t) x)))
double code(double x, double y, double z, double t, double a, double b) {
return fma(y, z, fma(a, fma(z, b, t), x));
}
function code(x, y, z, t, a, b) return fma(y, z, fma(a, fma(z, b, t), x)) end
code[x_, y_, z_, t_, a_, b_] := N[(y * z + N[(a * N[(z * b + t), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y, z, \mathsf{fma}\left(a, \mathsf{fma}\left(z, b, t\right), x\right)\right)
\end{array}
Initial program 90.3%
associate-+l+90.3%
+-commutative90.3%
associate-+l+90.3%
fma-def91.9%
+-commutative91.9%
*-commutative91.9%
associate-*l*92.6%
distribute-lft-out96.1%
fma-def96.1%
+-commutative96.1%
fma-def96.1%
Simplified96.1%
Final simplification96.1%
(FPCore (x y z t a b) :precision binary64 (fma a (+ t (* z b)) (fma y z x)))
double code(double x, double y, double z, double t, double a, double b) {
return fma(a, (t + (z * b)), fma(y, z, x));
}
function code(x, y, z, t, a, b) return fma(a, Float64(t + Float64(z * b)), fma(y, z, x)) end
code[x_, y_, z_, t_, a_, b_] := N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision] + N[(y * z + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(a, t + z \cdot b, \mathsf{fma}\left(y, z, x\right)\right)
\end{array}
Initial program 90.3%
associate-+l+90.3%
+-commutative90.3%
*-commutative90.3%
associate-*l*91.0%
distribute-lft-out93.8%
fma-def95.3%
+-commutative95.3%
fma-def95.3%
Simplified95.3%
Final simplification95.3%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (+ (+ (* a t) (+ x (* z y))) (* b (* z a))))) (if (<= t_1 INFINITY) t_1 (+ x (* a (+ t (* z b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((a * t) + (x + (z * y))) + (b * (z * a));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = x + (a * (t + (z * b)));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((a * t) + (x + (z * y))) + (b * (z * a));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = x + (a * (t + (z * b)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = ((a * t) + (x + (z * y))) + (b * (z * a)) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = x + (a * (t + (z * b))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(a * t) + Float64(x + Float64(z * y))) + Float64(b * Float64(z * a))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(x + Float64(a * Float64(t + Float64(z * b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = ((a * t) + (x + (z * y))) + (b * (z * a)); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = x + (a * (t + (z * b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(a * t), $MachinePrecision] + N[(x + N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(x + N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot t + \left(x + z \cdot y\right)\right) + b \cdot \left(z \cdot a\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + a \cdot \left(t + z \cdot b\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 x (*.f64 y z)) (*.f64 t a)) (*.f64 (*.f64 a z) b)) < +inf.0Initial program 97.6%
if +inf.0 < (+.f64 (+.f64 (+.f64 x (*.f64 y z)) (*.f64 t a)) (*.f64 (*.f64 a z) b)) Initial program 0.0%
associate-+l+0.0%
+-commutative0.0%
associate-+l+0.0%
fma-def21.1%
+-commutative21.1%
*-commutative21.1%
associate-*l*31.6%
distribute-lft-out78.9%
fma-def78.9%
+-commutative78.9%
fma-def78.9%
Simplified78.9%
Taylor expanded in y around 0 73.9%
Final simplification95.8%
(FPCore (x y z t a b) :precision binary64 (if (<= a 3.6e+134) (+ (+ (* a t) (* a (* z b))) (+ x (* z y))) (+ x (* a (+ t (* z b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 3.6e+134) {
tmp = ((a * t) + (a * (z * b))) + (x + (z * y));
} else {
tmp = x + (a * (t + (z * b)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (a <= 3.6d+134) then
tmp = ((a * t) + (a * (z * b))) + (x + (z * y))
else
tmp = x + (a * (t + (z * b)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 3.6e+134) {
tmp = ((a * t) + (a * (z * b))) + (x + (z * y));
} else {
tmp = x + (a * (t + (z * b)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 3.6e+134: tmp = ((a * t) + (a * (z * b))) + (x + (z * y)) else: tmp = x + (a * (t + (z * b))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 3.6e+134) tmp = Float64(Float64(Float64(a * t) + Float64(a * Float64(z * b))) + Float64(x + Float64(z * y))); else tmp = Float64(x + Float64(a * Float64(t + Float64(z * b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 3.6e+134) tmp = ((a * t) + (a * (z * b))) + (x + (z * y)); else tmp = x + (a * (t + (z * b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 3.6e+134], N[(N[(N[(a * t), $MachinePrecision] + N[(a * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x + N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 3.6 \cdot 10^{+134}:\\
\;\;\;\;\left(a \cdot t + a \cdot \left(z \cdot b\right)\right) + \left(x + z \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;x + a \cdot \left(t + z \cdot b\right)\\
\end{array}
\end{array}
if a < 3.59999999999999988e134Initial program 93.9%
associate-+l+93.9%
associate-*l*93.9%
Simplified93.9%
if 3.59999999999999988e134 < a Initial program 73.0%
associate-+l+73.0%
+-commutative73.0%
associate-+l+73.0%
fma-def82.1%
+-commutative82.1%
*-commutative82.1%
associate-*l*86.4%
distribute-lft-out93.2%
fma-def93.2%
+-commutative93.2%
fma-def93.2%
Simplified93.2%
Taylor expanded in y around 0 91.0%
Final simplification93.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* a t))))
(if (<= a -3.7e+240)
(* b (* z a))
(if (<= a -9e+157)
t_1
(if (<= a -1.65e+75)
(* a (* z b))
(if (or (<= a -8.2e-54) (not (<= a 4.4e-63))) t_1 (+ x (* z y))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * t);
double tmp;
if (a <= -3.7e+240) {
tmp = b * (z * a);
} else if (a <= -9e+157) {
tmp = t_1;
} else if (a <= -1.65e+75) {
tmp = a * (z * b);
} else if ((a <= -8.2e-54) || !(a <= 4.4e-63)) {
tmp = t_1;
} else {
tmp = x + (z * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = x + (a * t)
if (a <= (-3.7d+240)) then
tmp = b * (z * a)
else if (a <= (-9d+157)) then
tmp = t_1
else if (a <= (-1.65d+75)) then
tmp = a * (z * b)
else if ((a <= (-8.2d-54)) .or. (.not. (a <= 4.4d-63))) then
tmp = t_1
else
tmp = x + (z * y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * t);
double tmp;
if (a <= -3.7e+240) {
tmp = b * (z * a);
} else if (a <= -9e+157) {
tmp = t_1;
} else if (a <= -1.65e+75) {
tmp = a * (z * b);
} else if ((a <= -8.2e-54) || !(a <= 4.4e-63)) {
tmp = t_1;
} else {
tmp = x + (z * y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (a * t) tmp = 0 if a <= -3.7e+240: tmp = b * (z * a) elif a <= -9e+157: tmp = t_1 elif a <= -1.65e+75: tmp = a * (z * b) elif (a <= -8.2e-54) or not (a <= 4.4e-63): tmp = t_1 else: tmp = x + (z * y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(a * t)) tmp = 0.0 if (a <= -3.7e+240) tmp = Float64(b * Float64(z * a)); elseif (a <= -9e+157) tmp = t_1; elseif (a <= -1.65e+75) tmp = Float64(a * Float64(z * b)); elseif ((a <= -8.2e-54) || !(a <= 4.4e-63)) tmp = t_1; else tmp = Float64(x + Float64(z * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (a * t); tmp = 0.0; if (a <= -3.7e+240) tmp = b * (z * a); elseif (a <= -9e+157) tmp = t_1; elseif (a <= -1.65e+75) tmp = a * (z * b); elseif ((a <= -8.2e-54) || ~((a <= 4.4e-63))) tmp = t_1; else tmp = x + (z * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3.7e+240], N[(b * N[(z * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -9e+157], t$95$1, If[LessEqual[a, -1.65e+75], N[(a * N[(z * b), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, -8.2e-54], N[Not[LessEqual[a, 4.4e-63]], $MachinePrecision]], t$95$1, N[(x + N[(z * y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + a \cdot t\\
\mathbf{if}\;a \leq -3.7 \cdot 10^{+240}:\\
\;\;\;\;b \cdot \left(z \cdot a\right)\\
\mathbf{elif}\;a \leq -9 \cdot 10^{+157}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -1.65 \cdot 10^{+75}:\\
\;\;\;\;a \cdot \left(z \cdot b\right)\\
\mathbf{elif}\;a \leq -8.2 \cdot 10^{-54} \lor \neg \left(a \leq 4.4 \cdot 10^{-63}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + z \cdot y\\
\end{array}
\end{array}
if a < -3.7000000000000001e240Initial program 82.4%
associate-+l+82.4%
+-commutative82.4%
associate-+l+82.4%
fma-def82.4%
+-commutative82.4%
*-commutative82.4%
associate-*l*82.2%
distribute-lft-out93.9%
fma-def93.9%
+-commutative93.9%
fma-def93.9%
Simplified93.9%
Taylor expanded in a around inf 93.9%
Taylor expanded in z around inf 70.8%
associate-*r*76.5%
Simplified76.5%
if -3.7000000000000001e240 < a < -8.9999999999999997e157 or -1.64999999999999999e75 < a < -8.2000000000000001e-54 or 4.3999999999999999e-63 < a Initial program 86.7%
associate-+l+86.7%
+-commutative86.7%
associate-+l+86.7%
fma-def89.9%
+-commutative89.9%
*-commutative89.9%
associate-*l*93.0%
distribute-lft-out96.1%
fma-def96.1%
+-commutative96.1%
fma-def96.1%
Simplified96.1%
Taylor expanded in y around 0 86.5%
Taylor expanded in z around 0 61.1%
if -8.9999999999999997e157 < a < -1.64999999999999999e75Initial program 67.6%
associate-+l+67.6%
+-commutative67.6%
associate-+l+67.6%
fma-def67.6%
+-commutative67.6%
*-commutative67.6%
associate-*l*79.7%
distribute-lft-out99.7%
fma-def99.7%
+-commutative99.7%
fma-def99.7%
Simplified99.7%
Taylor expanded in a around inf 80.0%
Taylor expanded in z around inf 56.1%
if -8.2000000000000001e-54 < a < 4.3999999999999999e-63Initial program 100.0%
associate-+l+100.0%
+-commutative100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
*-commutative100.0%
associate-*l*96.0%
distribute-lft-out96.0%
fma-def96.0%
+-commutative96.0%
fma-def96.0%
Simplified96.0%
Taylor expanded in a around 0 78.9%
Final simplification68.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* a t))))
(if (<= z -4.5e+262)
(* z (* a b))
(if (<= z -1.02e+210)
(* z y)
(if (<= z -1.38e+169)
t_1
(if (<= z -4.2e-63)
(* z y)
(if (<= z 4.1e+79) t_1 (* b (* z a)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * t);
double tmp;
if (z <= -4.5e+262) {
tmp = z * (a * b);
} else if (z <= -1.02e+210) {
tmp = z * y;
} else if (z <= -1.38e+169) {
tmp = t_1;
} else if (z <= -4.2e-63) {
tmp = z * y;
} else if (z <= 4.1e+79) {
tmp = t_1;
} else {
tmp = b * (z * a);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = x + (a * t)
if (z <= (-4.5d+262)) then
tmp = z * (a * b)
else if (z <= (-1.02d+210)) then
tmp = z * y
else if (z <= (-1.38d+169)) then
tmp = t_1
else if (z <= (-4.2d-63)) then
tmp = z * y
else if (z <= 4.1d+79) then
tmp = t_1
else
tmp = b * (z * a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (a * t);
double tmp;
if (z <= -4.5e+262) {
tmp = z * (a * b);
} else if (z <= -1.02e+210) {
tmp = z * y;
} else if (z <= -1.38e+169) {
tmp = t_1;
} else if (z <= -4.2e-63) {
tmp = z * y;
} else if (z <= 4.1e+79) {
tmp = t_1;
} else {
tmp = b * (z * a);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (a * t) tmp = 0 if z <= -4.5e+262: tmp = z * (a * b) elif z <= -1.02e+210: tmp = z * y elif z <= -1.38e+169: tmp = t_1 elif z <= -4.2e-63: tmp = z * y elif z <= 4.1e+79: tmp = t_1 else: tmp = b * (z * a) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(a * t)) tmp = 0.0 if (z <= -4.5e+262) tmp = Float64(z * Float64(a * b)); elseif (z <= -1.02e+210) tmp = Float64(z * y); elseif (z <= -1.38e+169) tmp = t_1; elseif (z <= -4.2e-63) tmp = Float64(z * y); elseif (z <= 4.1e+79) tmp = t_1; else tmp = Float64(b * Float64(z * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (a * t); tmp = 0.0; if (z <= -4.5e+262) tmp = z * (a * b); elseif (z <= -1.02e+210) tmp = z * y; elseif (z <= -1.38e+169) tmp = t_1; elseif (z <= -4.2e-63) tmp = z * y; elseif (z <= 4.1e+79) tmp = t_1; else tmp = b * (z * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.5e+262], N[(z * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.02e+210], N[(z * y), $MachinePrecision], If[LessEqual[z, -1.38e+169], t$95$1, If[LessEqual[z, -4.2e-63], N[(z * y), $MachinePrecision], If[LessEqual[z, 4.1e+79], t$95$1, N[(b * N[(z * a), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + a \cdot t\\
\mathbf{if}\;z \leq -4.5 \cdot 10^{+262}:\\
\;\;\;\;z \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;z \leq -1.02 \cdot 10^{+210}:\\
\;\;\;\;z \cdot y\\
\mathbf{elif}\;z \leq -1.38 \cdot 10^{+169}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -4.2 \cdot 10^{-63}:\\
\;\;\;\;z \cdot y\\
\mathbf{elif}\;z \leq 4.1 \cdot 10^{+79}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(z \cdot a\right)\\
\end{array}
\end{array}
if z < -4.49999999999999972e262Initial program 35.2%
associate-+l+35.2%
+-commutative35.2%
associate-+l+35.2%
fma-def57.4%
+-commutative57.4%
*-commutative57.4%
associate-*l*78.4%
distribute-lft-out78.4%
fma-def78.4%
+-commutative78.4%
fma-def78.4%
Simplified78.4%
Taylor expanded in z around inf 88.9%
Taylor expanded in a around inf 67.3%
associate-*r*77.8%
*-commutative77.8%
Simplified77.8%
if -4.49999999999999972e262 < z < -1.02000000000000005e210 or -1.38e169 < z < -4.2e-63Initial program 93.7%
associate-+l+93.7%
+-commutative93.7%
associate-+l+93.7%
fma-def93.7%
+-commutative93.7%
*-commutative93.7%
associate-*l*95.8%
distribute-lft-out95.8%
fma-def95.8%
+-commutative95.8%
fma-def95.8%
Simplified95.8%
Taylor expanded in y around inf 56.3%
*-commutative56.3%
Simplified56.3%
if -1.02000000000000005e210 < z < -1.38e169 or -4.2e-63 < z < 4.1e79Initial program 94.6%
associate-+l+94.6%
+-commutative94.6%
associate-+l+94.6%
fma-def95.2%
+-commutative95.2%
*-commutative95.2%
associate-*l*94.6%
distribute-lft-out98.2%
fma-def98.2%
+-commutative98.2%
fma-def98.2%
Simplified98.2%
Taylor expanded in y around 0 87.2%
Taylor expanded in z around 0 69.8%
if 4.1e79 < z Initial program 78.8%
associate-+l+78.8%
+-commutative78.8%
associate-+l+78.8%
fma-def81.8%
+-commutative81.8%
*-commutative81.8%
associate-*l*81.8%
distribute-lft-out90.9%
fma-def90.9%
+-commutative90.9%
fma-def90.9%
Simplified90.9%
Taylor expanded in a around inf 59.9%
Taylor expanded in z around inf 49.4%
associate-*r*49.6%
Simplified49.6%
Final simplification65.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* a (+ t (* z b)))))
(if (<= a -4.2e+219)
t_1
(if (<= a -3.6e+202)
(+ x (* a t))
(if (or (<= a -2.15e-54) (not (<= a 2800000.0))) t_1 (+ x (* z y)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (t + (z * b));
double tmp;
if (a <= -4.2e+219) {
tmp = t_1;
} else if (a <= -3.6e+202) {
tmp = x + (a * t);
} else if ((a <= -2.15e-54) || !(a <= 2800000.0)) {
tmp = t_1;
} else {
tmp = x + (z * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = a * (t + (z * b))
if (a <= (-4.2d+219)) then
tmp = t_1
else if (a <= (-3.6d+202)) then
tmp = x + (a * t)
else if ((a <= (-2.15d-54)) .or. (.not. (a <= 2800000.0d0))) then
tmp = t_1
else
tmp = x + (z * y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = a * (t + (z * b));
double tmp;
if (a <= -4.2e+219) {
tmp = t_1;
} else if (a <= -3.6e+202) {
tmp = x + (a * t);
} else if ((a <= -2.15e-54) || !(a <= 2800000.0)) {
tmp = t_1;
} else {
tmp = x + (z * y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = a * (t + (z * b)) tmp = 0 if a <= -4.2e+219: tmp = t_1 elif a <= -3.6e+202: tmp = x + (a * t) elif (a <= -2.15e-54) or not (a <= 2800000.0): tmp = t_1 else: tmp = x + (z * y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(a * Float64(t + Float64(z * b))) tmp = 0.0 if (a <= -4.2e+219) tmp = t_1; elseif (a <= -3.6e+202) tmp = Float64(x + Float64(a * t)); elseif ((a <= -2.15e-54) || !(a <= 2800000.0)) tmp = t_1; else tmp = Float64(x + Float64(z * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a * (t + (z * b)); tmp = 0.0; if (a <= -4.2e+219) tmp = t_1; elseif (a <= -3.6e+202) tmp = x + (a * t); elseif ((a <= -2.15e-54) || ~((a <= 2800000.0))) tmp = t_1; else tmp = x + (z * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.2e+219], t$95$1, If[LessEqual[a, -3.6e+202], N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, -2.15e-54], N[Not[LessEqual[a, 2800000.0]], $MachinePrecision]], t$95$1, N[(x + N[(z * y), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(t + z \cdot b\right)\\
\mathbf{if}\;a \leq -4.2 \cdot 10^{+219}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq -3.6 \cdot 10^{+202}:\\
\;\;\;\;x + a \cdot t\\
\mathbf{elif}\;a \leq -2.15 \cdot 10^{-54} \lor \neg \left(a \leq 2800000\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;x + z \cdot y\\
\end{array}
\end{array}
if a < -4.19999999999999976e219 or -3.60000000000000008e202 < a < -2.15e-54 or 2.8e6 < a Initial program 82.1%
associate-+l+82.1%
+-commutative82.1%
associate-+l+82.1%
fma-def85.0%
+-commutative85.0%
*-commutative85.0%
associate-*l*90.5%
distribute-lft-out97.0%
fma-def97.0%
+-commutative97.0%
fma-def97.0%
Simplified97.0%
Taylor expanded in a around inf 77.1%
if -4.19999999999999976e219 < a < -3.60000000000000008e202Initial program 100.0%
associate-+l+100.0%
+-commutative100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
*-commutative100.0%
associate-*l*100.0%
distribute-lft-out100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in y around 0 86.7%
Taylor expanded in z around 0 86.7%
if -2.15e-54 < a < 2.8e6Initial program 100.0%
associate-+l+100.0%
+-commutative100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
*-commutative100.0%
associate-*l*94.7%
distribute-lft-out94.8%
fma-def94.8%
+-commutative94.8%
fma-def94.8%
Simplified94.8%
Taylor expanded in a around 0 77.3%
Final simplification77.4%
(FPCore (x y z t a b) :precision binary64 (if (or (<= a -9.2e-144) (not (<= a 1.9e-125))) (+ x (* a (+ t (* z b)))) (+ x (* z y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -9.2e-144) || !(a <= 1.9e-125)) {
tmp = x + (a * (t + (z * b)));
} else {
tmp = x + (z * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if ((a <= (-9.2d-144)) .or. (.not. (a <= 1.9d-125))) then
tmp = x + (a * (t + (z * b)))
else
tmp = x + (z * y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -9.2e-144) || !(a <= 1.9e-125)) {
tmp = x + (a * (t + (z * b)));
} else {
tmp = x + (z * y);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (a <= -9.2e-144) or not (a <= 1.9e-125): tmp = x + (a * (t + (z * b))) else: tmp = x + (z * y) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((a <= -9.2e-144) || !(a <= 1.9e-125)) tmp = Float64(x + Float64(a * Float64(t + Float64(z * b)))); else tmp = Float64(x + Float64(z * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((a <= -9.2e-144) || ~((a <= 1.9e-125))) tmp = x + (a * (t + (z * b))); else tmp = x + (z * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[a, -9.2e-144], N[Not[LessEqual[a, 1.9e-125]], $MachinePrecision]], N[(x + N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(z * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -9.2 \cdot 10^{-144} \lor \neg \left(a \leq 1.9 \cdot 10^{-125}\right):\\
\;\;\;\;x + a \cdot \left(t + z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;x + z \cdot y\\
\end{array}
\end{array}
if a < -9.2e-144 or 1.9000000000000001e-125 < a Initial program 86.6%
associate-+l+86.6%
+-commutative86.6%
associate-+l+86.6%
fma-def88.8%
+-commutative88.8%
*-commutative88.8%
associate-*l*91.4%
distribute-lft-out96.2%
fma-def96.2%
+-commutative96.2%
fma-def96.2%
Simplified96.2%
Taylor expanded in y around 0 84.9%
if -9.2e-144 < a < 1.9000000000000001e-125Initial program 100.0%
associate-+l+100.0%
+-commutative100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
*-commutative100.0%
associate-*l*95.8%
distribute-lft-out95.9%
fma-def95.9%
+-commutative95.9%
fma-def95.9%
Simplified95.9%
Taylor expanded in a around 0 88.6%
Final simplification86.0%
(FPCore (x y z t a b) :precision binary64 (if (or (<= a -1.12e-54) (not (<= a 3350000.0))) (+ x (* a (+ t (* z b)))) (+ (+ x (* a t)) (* z y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -1.12e-54) || !(a <= 3350000.0)) {
tmp = x + (a * (t + (z * b)));
} else {
tmp = (x + (a * t)) + (z * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if ((a <= (-1.12d-54)) .or. (.not. (a <= 3350000.0d0))) then
tmp = x + (a * (t + (z * b)))
else
tmp = (x + (a * t)) + (z * y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -1.12e-54) || !(a <= 3350000.0)) {
tmp = x + (a * (t + (z * b)));
} else {
tmp = (x + (a * t)) + (z * y);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (a <= -1.12e-54) or not (a <= 3350000.0): tmp = x + (a * (t + (z * b))) else: tmp = (x + (a * t)) + (z * y) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((a <= -1.12e-54) || !(a <= 3350000.0)) tmp = Float64(x + Float64(a * Float64(t + Float64(z * b)))); else tmp = Float64(Float64(x + Float64(a * t)) + Float64(z * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((a <= -1.12e-54) || ~((a <= 3350000.0))) tmp = x + (a * (t + (z * b))); else tmp = (x + (a * t)) + (z * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[a, -1.12e-54], N[Not[LessEqual[a, 3350000.0]], $MachinePrecision]], N[(x + N[(a * N[(t + N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision] + N[(z * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.12 \cdot 10^{-54} \lor \neg \left(a \leq 3350000\right):\\
\;\;\;\;x + a \cdot \left(t + z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + a \cdot t\right) + z \cdot y\\
\end{array}
\end{array}
if a < -1.11999999999999994e-54 or 3.35e6 < a Initial program 82.9%
associate-+l+82.9%
+-commutative82.9%
associate-+l+82.9%
fma-def85.7%
+-commutative85.7%
*-commutative85.7%
associate-*l*91.0%
distribute-lft-out97.2%
fma-def97.2%
+-commutative97.2%
fma-def97.2%
Simplified97.2%
Taylor expanded in y around 0 88.5%
if -1.11999999999999994e-54 < a < 3.35e6Initial program 100.0%
associate-+l+100.0%
+-commutative100.0%
associate-+l+100.0%
fma-def100.0%
+-commutative100.0%
*-commutative100.0%
associate-*l*94.7%
distribute-lft-out94.8%
fma-def94.8%
+-commutative94.8%
fma-def94.8%
Simplified94.8%
Taylor expanded in b around 0 90.2%
Final simplification89.2%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -9.5e-34)
(* a t)
(if (<= t -1.3e-278)
(* a (* z b))
(if (<= t 2.95e-161) x (if (<= t 1350.0) (* z y) (* a t))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -9.5e-34) {
tmp = a * t;
} else if (t <= -1.3e-278) {
tmp = a * (z * b);
} else if (t <= 2.95e-161) {
tmp = x;
} else if (t <= 1350.0) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (t <= (-9.5d-34)) then
tmp = a * t
else if (t <= (-1.3d-278)) then
tmp = a * (z * b)
else if (t <= 2.95d-161) then
tmp = x
else if (t <= 1350.0d0) then
tmp = z * y
else
tmp = a * t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -9.5e-34) {
tmp = a * t;
} else if (t <= -1.3e-278) {
tmp = a * (z * b);
} else if (t <= 2.95e-161) {
tmp = x;
} else if (t <= 1350.0) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -9.5e-34: tmp = a * t elif t <= -1.3e-278: tmp = a * (z * b) elif t <= 2.95e-161: tmp = x elif t <= 1350.0: tmp = z * y else: tmp = a * t return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -9.5e-34) tmp = Float64(a * t); elseif (t <= -1.3e-278) tmp = Float64(a * Float64(z * b)); elseif (t <= 2.95e-161) tmp = x; elseif (t <= 1350.0) tmp = Float64(z * y); else tmp = Float64(a * t); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -9.5e-34) tmp = a * t; elseif (t <= -1.3e-278) tmp = a * (z * b); elseif (t <= 2.95e-161) tmp = x; elseif (t <= 1350.0) tmp = z * y; else tmp = a * t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -9.5e-34], N[(a * t), $MachinePrecision], If[LessEqual[t, -1.3e-278], N[(a * N[(z * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.95e-161], x, If[LessEqual[t, 1350.0], N[(z * y), $MachinePrecision], N[(a * t), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -9.5 \cdot 10^{-34}:\\
\;\;\;\;a \cdot t\\
\mathbf{elif}\;t \leq -1.3 \cdot 10^{-278}:\\
\;\;\;\;a \cdot \left(z \cdot b\right)\\
\mathbf{elif}\;t \leq 2.95 \cdot 10^{-161}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1350:\\
\;\;\;\;z \cdot y\\
\mathbf{else}:\\
\;\;\;\;a \cdot t\\
\end{array}
\end{array}
if t < -9.49999999999999985e-34 or 1350 < t Initial program 86.7%
associate-+l+86.7%
+-commutative86.7%
associate-+l+86.7%
fma-def87.5%
+-commutative87.5%
*-commutative87.5%
associate-*l*88.3%
distribute-lft-out95.8%
fma-def95.8%
+-commutative95.8%
fma-def95.8%
Simplified95.8%
Taylor expanded in a around inf 63.4%
Taylor expanded in z around 0 51.4%
*-commutative51.4%
Simplified51.4%
if -9.49999999999999985e-34 < t < -1.2999999999999999e-278Initial program 93.5%
associate-+l+93.5%
+-commutative93.5%
associate-+l+93.5%
fma-def95.1%
+-commutative95.1%
*-commutative95.1%
associate-*l*95.1%
distribute-lft-out95.1%
fma-def95.1%
+-commutative95.1%
fma-def95.1%
Simplified95.1%
Taylor expanded in a around inf 55.3%
Taylor expanded in z around inf 52.2%
if -1.2999999999999999e-278 < t < 2.9500000000000001e-161Initial program 94.4%
associate-+l+94.4%
+-commutative94.4%
associate-+l+94.4%
fma-def97.3%
+-commutative97.3%
*-commutative97.3%
associate-*l*94.5%
distribute-lft-out94.5%
fma-def94.5%
+-commutative94.5%
fma-def94.5%
Simplified94.5%
Taylor expanded in y around 0 75.4%
Taylor expanded in x around inf 52.9%
if 2.9500000000000001e-161 < t < 1350Initial program 92.7%
associate-+l+92.7%
+-commutative92.7%
associate-+l+92.7%
fma-def95.3%
+-commutative95.3%
*-commutative95.3%
associate-*l*100.0%
distribute-lft-out100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in y around inf 46.9%
*-commutative46.9%
Simplified46.9%
Final simplification51.1%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -2.9e-33)
(* a t)
(if (<= t -3.9e-281)
(* z (* a b))
(if (<= t 1.15e-160) x (if (<= t 1.25) (* z y) (* a t))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -2.9e-33) {
tmp = a * t;
} else if (t <= -3.9e-281) {
tmp = z * (a * b);
} else if (t <= 1.15e-160) {
tmp = x;
} else if (t <= 1.25) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (t <= (-2.9d-33)) then
tmp = a * t
else if (t <= (-3.9d-281)) then
tmp = z * (a * b)
else if (t <= 1.15d-160) then
tmp = x
else if (t <= 1.25d0) then
tmp = z * y
else
tmp = a * t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -2.9e-33) {
tmp = a * t;
} else if (t <= -3.9e-281) {
tmp = z * (a * b);
} else if (t <= 1.15e-160) {
tmp = x;
} else if (t <= 1.25) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -2.9e-33: tmp = a * t elif t <= -3.9e-281: tmp = z * (a * b) elif t <= 1.15e-160: tmp = x elif t <= 1.25: tmp = z * y else: tmp = a * t return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -2.9e-33) tmp = Float64(a * t); elseif (t <= -3.9e-281) tmp = Float64(z * Float64(a * b)); elseif (t <= 1.15e-160) tmp = x; elseif (t <= 1.25) tmp = Float64(z * y); else tmp = Float64(a * t); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -2.9e-33) tmp = a * t; elseif (t <= -3.9e-281) tmp = z * (a * b); elseif (t <= 1.15e-160) tmp = x; elseif (t <= 1.25) tmp = z * y; else tmp = a * t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.9e-33], N[(a * t), $MachinePrecision], If[LessEqual[t, -3.9e-281], N[(z * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.15e-160], x, If[LessEqual[t, 1.25], N[(z * y), $MachinePrecision], N[(a * t), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.9 \cdot 10^{-33}:\\
\;\;\;\;a \cdot t\\
\mathbf{elif}\;t \leq -3.9 \cdot 10^{-281}:\\
\;\;\;\;z \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{-160}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 1.25:\\
\;\;\;\;z \cdot y\\
\mathbf{else}:\\
\;\;\;\;a \cdot t\\
\end{array}
\end{array}
if t < -2.90000000000000003e-33 or 1.25 < t Initial program 86.7%
associate-+l+86.7%
+-commutative86.7%
associate-+l+86.7%
fma-def87.5%
+-commutative87.5%
*-commutative87.5%
associate-*l*88.3%
distribute-lft-out95.8%
fma-def95.8%
+-commutative95.8%
fma-def95.8%
Simplified95.8%
Taylor expanded in a around inf 63.4%
Taylor expanded in z around 0 51.4%
*-commutative51.4%
Simplified51.4%
if -2.90000000000000003e-33 < t < -3.9000000000000002e-281Initial program 93.5%
associate-+l+93.5%
+-commutative93.5%
associate-+l+93.5%
fma-def95.1%
+-commutative95.1%
*-commutative95.1%
associate-*l*95.1%
distribute-lft-out95.1%
fma-def95.1%
+-commutative95.1%
fma-def95.1%
Simplified95.1%
Taylor expanded in z around inf 69.8%
Taylor expanded in a around inf 52.2%
associate-*r*52.3%
*-commutative52.3%
Simplified52.3%
if -3.9000000000000002e-281 < t < 1.14999999999999992e-160Initial program 94.4%
associate-+l+94.4%
+-commutative94.4%
associate-+l+94.4%
fma-def97.3%
+-commutative97.3%
*-commutative97.3%
associate-*l*94.5%
distribute-lft-out94.5%
fma-def94.5%
+-commutative94.5%
fma-def94.5%
Simplified94.5%
Taylor expanded in y around 0 75.4%
Taylor expanded in x around inf 52.9%
if 1.14999999999999992e-160 < t < 1.25Initial program 92.7%
associate-+l+92.7%
+-commutative92.7%
associate-+l+92.7%
fma-def95.3%
+-commutative95.3%
*-commutative95.3%
associate-*l*100.0%
distribute-lft-out100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in y around inf 46.9%
*-commutative46.9%
Simplified46.9%
Final simplification51.1%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -3e-33)
(* a t)
(if (<= t -8.4e-283)
(* b (* z a))
(if (<= t 5.3e-160) x (if (<= t 22000.0) (* z y) (* a t))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -3e-33) {
tmp = a * t;
} else if (t <= -8.4e-283) {
tmp = b * (z * a);
} else if (t <= 5.3e-160) {
tmp = x;
} else if (t <= 22000.0) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (t <= (-3d-33)) then
tmp = a * t
else if (t <= (-8.4d-283)) then
tmp = b * (z * a)
else if (t <= 5.3d-160) then
tmp = x
else if (t <= 22000.0d0) then
tmp = z * y
else
tmp = a * t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -3e-33) {
tmp = a * t;
} else if (t <= -8.4e-283) {
tmp = b * (z * a);
} else if (t <= 5.3e-160) {
tmp = x;
} else if (t <= 22000.0) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -3e-33: tmp = a * t elif t <= -8.4e-283: tmp = b * (z * a) elif t <= 5.3e-160: tmp = x elif t <= 22000.0: tmp = z * y else: tmp = a * t return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -3e-33) tmp = Float64(a * t); elseif (t <= -8.4e-283) tmp = Float64(b * Float64(z * a)); elseif (t <= 5.3e-160) tmp = x; elseif (t <= 22000.0) tmp = Float64(z * y); else tmp = Float64(a * t); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -3e-33) tmp = a * t; elseif (t <= -8.4e-283) tmp = b * (z * a); elseif (t <= 5.3e-160) tmp = x; elseif (t <= 22000.0) tmp = z * y; else tmp = a * t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -3e-33], N[(a * t), $MachinePrecision], If[LessEqual[t, -8.4e-283], N[(b * N[(z * a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.3e-160], x, If[LessEqual[t, 22000.0], N[(z * y), $MachinePrecision], N[(a * t), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3 \cdot 10^{-33}:\\
\;\;\;\;a \cdot t\\
\mathbf{elif}\;t \leq -8.4 \cdot 10^{-283}:\\
\;\;\;\;b \cdot \left(z \cdot a\right)\\
\mathbf{elif}\;t \leq 5.3 \cdot 10^{-160}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 22000:\\
\;\;\;\;z \cdot y\\
\mathbf{else}:\\
\;\;\;\;a \cdot t\\
\end{array}
\end{array}
if t < -3.0000000000000002e-33 or 22000 < t Initial program 86.7%
associate-+l+86.7%
+-commutative86.7%
associate-+l+86.7%
fma-def87.5%
+-commutative87.5%
*-commutative87.5%
associate-*l*88.3%
distribute-lft-out95.8%
fma-def95.8%
+-commutative95.8%
fma-def95.8%
Simplified95.8%
Taylor expanded in a around inf 63.4%
Taylor expanded in z around 0 51.4%
*-commutative51.4%
Simplified51.4%
if -3.0000000000000002e-33 < t < -8.39999999999999989e-283Initial program 93.5%
associate-+l+93.5%
+-commutative93.5%
associate-+l+93.5%
fma-def95.1%
+-commutative95.1%
*-commutative95.1%
associate-*l*95.1%
distribute-lft-out95.1%
fma-def95.1%
+-commutative95.1%
fma-def95.1%
Simplified95.1%
Taylor expanded in a around inf 55.3%
Taylor expanded in z around inf 52.2%
associate-*r*55.4%
Simplified55.4%
if -8.39999999999999989e-283 < t < 5.3000000000000001e-160Initial program 94.4%
associate-+l+94.4%
+-commutative94.4%
associate-+l+94.4%
fma-def97.3%
+-commutative97.3%
*-commutative97.3%
associate-*l*94.5%
distribute-lft-out94.5%
fma-def94.5%
+-commutative94.5%
fma-def94.5%
Simplified94.5%
Taylor expanded in y around 0 75.4%
Taylor expanded in x around inf 52.9%
if 5.3000000000000001e-160 < t < 22000Initial program 92.7%
associate-+l+92.7%
+-commutative92.7%
associate-+l+92.7%
fma-def95.3%
+-commutative95.3%
*-commutative95.3%
associate-*l*100.0%
distribute-lft-out100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in y around inf 46.9%
*-commutative46.9%
Simplified46.9%
Final simplification51.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= z -4.1e-63) (not (<= z 3.2e-38))) (* z (+ y (* a b))) (+ x (* a t))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -4.1e-63) || !(z <= 3.2e-38)) {
tmp = z * (y + (a * b));
} else {
tmp = x + (a * t);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if ((z <= (-4.1d-63)) .or. (.not. (z <= 3.2d-38))) then
tmp = z * (y + (a * b))
else
tmp = x + (a * t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((z <= -4.1e-63) || !(z <= 3.2e-38)) {
tmp = z * (y + (a * b));
} else {
tmp = x + (a * t);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (z <= -4.1e-63) or not (z <= 3.2e-38): tmp = z * (y + (a * b)) else: tmp = x + (a * t) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((z <= -4.1e-63) || !(z <= 3.2e-38)) tmp = Float64(z * Float64(y + Float64(a * b))); else tmp = Float64(x + Float64(a * t)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((z <= -4.1e-63) || ~((z <= 3.2e-38))) tmp = z * (y + (a * b)); else tmp = x + (a * t); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[z, -4.1e-63], N[Not[LessEqual[z, 3.2e-38]], $MachinePrecision]], N[(z * N[(y + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(a * t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.1 \cdot 10^{-63} \lor \neg \left(z \leq 3.2 \cdot 10^{-38}\right):\\
\;\;\;\;z \cdot \left(y + a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;x + a \cdot t\\
\end{array}
\end{array}
if z < -4.0999999999999998e-63 or 3.19999999999999977e-38 < z Initial program 83.5%
associate-+l+83.5%
+-commutative83.5%
associate-+l+83.5%
fma-def86.4%
+-commutative86.4%
*-commutative86.4%
associate-*l*87.8%
distribute-lft-out92.9%
fma-def92.9%
+-commutative92.9%
fma-def92.9%
Simplified92.9%
Taylor expanded in z around inf 74.6%
if -4.0999999999999998e-63 < z < 3.19999999999999977e-38Initial program 98.3%
associate-+l+98.3%
+-commutative98.3%
associate-+l+98.3%
fma-def98.3%
+-commutative98.3%
*-commutative98.3%
associate-*l*98.2%
distribute-lft-out99.9%
fma-def99.9%
+-commutative99.9%
fma-def99.9%
Simplified99.9%
Taylor expanded in y around 0 89.4%
Taylor expanded in z around 0 78.6%
Final simplification76.5%
(FPCore (x y z t a b) :precision binary64 (if (<= t -1.05e-58) (* a t) (if (<= t 3e-162) x (if (<= t 2.15) (* z y) (* a t)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.05e-58) {
tmp = a * t;
} else if (t <= 3e-162) {
tmp = x;
} else if (t <= 2.15) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (t <= (-1.05d-58)) then
tmp = a * t
else if (t <= 3d-162) then
tmp = x
else if (t <= 2.15d0) then
tmp = z * y
else
tmp = a * t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.05e-58) {
tmp = a * t;
} else if (t <= 3e-162) {
tmp = x;
} else if (t <= 2.15) {
tmp = z * y;
} else {
tmp = a * t;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -1.05e-58: tmp = a * t elif t <= 3e-162: tmp = x elif t <= 2.15: tmp = z * y else: tmp = a * t return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -1.05e-58) tmp = Float64(a * t); elseif (t <= 3e-162) tmp = x; elseif (t <= 2.15) tmp = Float64(z * y); else tmp = Float64(a * t); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -1.05e-58) tmp = a * t; elseif (t <= 3e-162) tmp = x; elseif (t <= 2.15) tmp = z * y; else tmp = a * t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.05e-58], N[(a * t), $MachinePrecision], If[LessEqual[t, 3e-162], x, If[LessEqual[t, 2.15], N[(z * y), $MachinePrecision], N[(a * t), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.05 \cdot 10^{-58}:\\
\;\;\;\;a \cdot t\\
\mathbf{elif}\;t \leq 3 \cdot 10^{-162}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq 2.15:\\
\;\;\;\;z \cdot y\\
\mathbf{else}:\\
\;\;\;\;a \cdot t\\
\end{array}
\end{array}
if t < -1.04999999999999994e-58 or 2.14999999999999991 < t Initial program 87.4%
associate-+l+87.4%
+-commutative87.4%
associate-+l+87.4%
fma-def88.2%
+-commutative88.2%
*-commutative88.2%
associate-*l*88.9%
distribute-lft-out96.0%
fma-def96.1%
+-commutative96.1%
fma-def96.1%
Simplified96.1%
Taylor expanded in a around inf 64.7%
Taylor expanded in z around 0 49.4%
*-commutative49.4%
Simplified49.4%
if -1.04999999999999994e-58 < t < 2.99999999999999999e-162Initial program 93.4%
associate-+l+93.4%
+-commutative93.4%
associate-+l+93.4%
fma-def95.6%
+-commutative95.6%
*-commutative95.6%
associate-*l*94.5%
distribute-lft-out94.5%
fma-def94.5%
+-commutative94.5%
fma-def94.5%
Simplified94.5%
Taylor expanded in y around 0 77.2%
Taylor expanded in x around inf 38.4%
if 2.99999999999999999e-162 < t < 2.14999999999999991Initial program 92.7%
associate-+l+92.7%
+-commutative92.7%
associate-+l+92.7%
fma-def95.3%
+-commutative95.3%
*-commutative95.3%
associate-*l*100.0%
distribute-lft-out100.0%
fma-def100.0%
+-commutative100.0%
fma-def100.0%
Simplified100.0%
Taylor expanded in y around inf 46.9%
*-commutative46.9%
Simplified46.9%
Final simplification45.2%
(FPCore (x y z t a b) :precision binary64 (if (<= x -8.5e+92) x (if (<= x 2.35e-42) (* a t) x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -8.5e+92) {
tmp = x;
} else if (x <= 2.35e-42) {
tmp = a * t;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (x <= (-8.5d+92)) then
tmp = x
else if (x <= 2.35d-42) then
tmp = a * t
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -8.5e+92) {
tmp = x;
} else if (x <= 2.35e-42) {
tmp = a * t;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -8.5e+92: tmp = x elif x <= 2.35e-42: tmp = a * t else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -8.5e+92) tmp = x; elseif (x <= 2.35e-42) tmp = Float64(a * t); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -8.5e+92) tmp = x; elseif (x <= 2.35e-42) tmp = a * t; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -8.5e+92], x, If[LessEqual[x, 2.35e-42], N[(a * t), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -8.5 \cdot 10^{+92}:\\
\;\;\;\;x\\
\mathbf{elif}\;x \leq 2.35 \cdot 10^{-42}:\\
\;\;\;\;a \cdot t\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if x < -8.5000000000000001e92 or 2.35e-42 < x Initial program 89.9%
associate-+l+89.9%
+-commutative89.9%
associate-+l+89.9%
fma-def92.5%
+-commutative92.5%
*-commutative92.5%
associate-*l*92.5%
distribute-lft-out95.9%
fma-def95.9%
+-commutative95.9%
fma-def95.9%
Simplified95.9%
Taylor expanded in y around 0 84.9%
Taylor expanded in x around inf 47.6%
if -8.5000000000000001e92 < x < 2.35e-42Initial program 90.7%
associate-+l+90.7%
+-commutative90.7%
associate-+l+90.7%
fma-def91.4%
+-commutative91.4%
*-commutative91.4%
associate-*l*92.7%
distribute-lft-out96.3%
fma-def96.3%
+-commutative96.3%
fma-def96.3%
Simplified96.3%
Taylor expanded in a around inf 62.5%
Taylor expanded in z around 0 37.1%
*-commutative37.1%
Simplified37.1%
Final simplification42.0%
(FPCore (x y z t a b) :precision binary64 x)
double code(double x, double y, double z, double t, double a, double b) {
return x;
}
real(8) function code(x, y, z, t, a, b)
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
code = x
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x;
}
def code(x, y, z, t, a, b): return x
function code(x, y, z, t, a, b) return x end
function tmp = code(x, y, z, t, a, b) tmp = x; end
code[x_, y_, z_, t_, a_, b_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 90.3%
associate-+l+90.3%
+-commutative90.3%
associate-+l+90.3%
fma-def91.9%
+-commutative91.9%
*-commutative91.9%
associate-*l*92.6%
distribute-lft-out96.1%
fma-def96.1%
+-commutative96.1%
fma-def96.1%
Simplified96.1%
Taylor expanded in y around 0 76.1%
Taylor expanded in x around inf 26.4%
Final simplification26.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (* z (+ (* b a) y)) (+ x (* t a)))))
(if (< z -11820553527347888000.0)
t_1
(if (< z 4.7589743188364287e-122)
(+ (* (+ (* b z) t) a) (+ (* z y) x))
t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z * ((b * a) + y)) + (x + (t * a));
double tmp;
if (z < -11820553527347888000.0) {
tmp = t_1;
} else if (z < 4.7589743188364287e-122) {
tmp = (((b * z) + t) * a) + ((z * y) + x);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = (z * ((b * a) + y)) + (x + (t * a))
if (z < (-11820553527347888000.0d0)) then
tmp = t_1
else if (z < 4.7589743188364287d-122) then
tmp = (((b * z) + t) * a) + ((z * y) + x)
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 t_1 = (z * ((b * a) + y)) + (x + (t * a));
double tmp;
if (z < -11820553527347888000.0) {
tmp = t_1;
} else if (z < 4.7589743188364287e-122) {
tmp = (((b * z) + t) * a) + ((z * y) + x);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z * ((b * a) + y)) + (x + (t * a)) tmp = 0 if z < -11820553527347888000.0: tmp = t_1 elif z < 4.7589743188364287e-122: tmp = (((b * z) + t) * a) + ((z * y) + x) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z * Float64(Float64(b * a) + y)) + Float64(x + Float64(t * a))) tmp = 0.0 if (z < -11820553527347888000.0) tmp = t_1; elseif (z < 4.7589743188364287e-122) tmp = Float64(Float64(Float64(Float64(b * z) + t) * a) + Float64(Float64(z * y) + x)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z * ((b * a) + y)) + (x + (t * a)); tmp = 0.0; if (z < -11820553527347888000.0) tmp = t_1; elseif (z < 4.7589743188364287e-122) tmp = (((b * z) + t) * a) + ((z * y) + x); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z * N[(N[(b * a), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision] + N[(x + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -11820553527347888000.0], t$95$1, If[Less[z, 4.7589743188364287e-122], N[(N[(N[(N[(b * z), $MachinePrecision] + t), $MachinePrecision] * a), $MachinePrecision] + N[(N[(z * y), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(b \cdot a + y\right) + \left(x + t \cdot a\right)\\
\mathbf{if}\;z < -11820553527347888000:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z < 4.7589743188364287 \cdot 10^{-122}:\\
\;\;\;\;\left(b \cdot z + t\right) \cdot a + \left(z \cdot y + x\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
herbie shell --seed 2023200
(FPCore (x y z t a b)
:name "Graphics.Rasterific.CubicBezier:cachedBezierAt from Rasterific-0.6.1"
:precision binary64
:herbie-target
(if (< z -11820553527347888000.0) (+ (* z (+ (* b a) y)) (+ x (* t a))) (if (< z 4.7589743188364287e-122) (+ (* (+ (* b z) t) a) (+ (* z y) x)) (+ (* z (+ (* b a) y)) (+ x (* t a)))))
(+ (+ (+ x (* y z)) (* t a)) (* (* a z) b)))