
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = 2.0d0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(Float64(a + Float64(b * c)) * c) * i))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i)); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = 2.0d0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(Float64(a + Float64(b * c)) * c) * i))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - (((a + (b * c)) * c) * i)); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(\left(a + b \cdot c\right) \cdot c\right) \cdot i\right)
\end{array}
(FPCore (x y z t a b c i) :precision binary64 (if (<= (- (+ (* y x) (* t z)) (* i (* (+ (* c b) a) c))) INFINITY) (* (fma (fma c b a) (* (- c) i) (fma t z (* y x))) 2.0) (* (* (* (fma c b a) i) -2.0) c)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((((y * x) + (t * z)) - (i * (((c * b) + a) * c))) <= ((double) INFINITY)) {
tmp = fma(fma(c, b, a), (-c * i), fma(t, z, (y * x))) * 2.0;
} else {
tmp = ((fma(c, b, a) * i) * -2.0) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (Float64(Float64(Float64(y * x) + Float64(t * z)) - Float64(i * Float64(Float64(Float64(c * b) + a) * c))) <= Inf) tmp = Float64(fma(fma(c, b, a), Float64(Float64(-c) * i), fma(t, z, Float64(y * x))) * 2.0); else tmp = Float64(Float64(Float64(fma(c, b, a) * i) * -2.0) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[N[(N[(N[(y * x), $MachinePrecision] + N[(t * z), $MachinePrecision]), $MachinePrecision] - N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(N[(c * b + a), $MachinePrecision] * N[((-c) * i), $MachinePrecision] + N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision] * -2.0), $MachinePrecision] * c), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(y \cdot x + t \cdot z\right) - i \cdot \left(\left(c \cdot b + a\right) \cdot c\right) \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(c, b, a\right), \left(-c\right) \cdot i, \mathsf{fma}\left(t, z, y \cdot x\right)\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\mathsf{fma}\left(c, b, a\right) \cdot i\right) \cdot -2\right) \cdot c\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) < +inf.0Initial program 93.2%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6497.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6497.6
Applied rewrites97.6%
if +inf.0 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) Initial program 0.0%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
Final simplification97.7%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* (* i c) a) -2.0)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+102)
t_1
(if (<= t_2 5e-90)
(* (* y x) 2.0)
(if (<= t_2 2e+87) (* 2.0 (* t z)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = ((i * c) * a) * -2.0;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+102) {
tmp = t_1;
} else if (t_2 <= 5e-90) {
tmp = (y * x) * 2.0;
} else if (t_2 <= 2e+87) {
tmp = 2.0 * (t * z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((i * c) * a) * (-2.0d0)
t_2 = i * (((c * b) + a) * c)
if (t_2 <= (-1d+102)) then
tmp = t_1
else if (t_2 <= 5d-90) then
tmp = (y * x) * 2.0d0
else if (t_2 <= 2d+87) then
tmp = 2.0d0 * (t * z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = ((i * c) * a) * -2.0;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+102) {
tmp = t_1;
} else if (t_2 <= 5e-90) {
tmp = (y * x) * 2.0;
} else if (t_2 <= 2e+87) {
tmp = 2.0 * (t * z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = ((i * c) * a) * -2.0 t_2 = i * (((c * b) + a) * c) tmp = 0 if t_2 <= -1e+102: tmp = t_1 elif t_2 <= 5e-90: tmp = (y * x) * 2.0 elif t_2 <= 2e+87: tmp = 2.0 * (t * z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(i * c) * a) * -2.0) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+102) tmp = t_1; elseif (t_2 <= 5e-90) tmp = Float64(Float64(y * x) * 2.0); elseif (t_2 <= 2e+87) tmp = Float64(2.0 * Float64(t * z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = ((i * c) * a) * -2.0; t_2 = i * (((c * b) + a) * c); tmp = 0.0; if (t_2 <= -1e+102) tmp = t_1; elseif (t_2 <= 5e-90) tmp = (y * x) * 2.0; elseif (t_2 <= 2e+87) tmp = 2.0 * (t * z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(i * c), $MachinePrecision] * a), $MachinePrecision] * -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+102], t$95$1, If[LessEqual[t$95$2, 5e-90], N[(N[(y * x), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$2, 2e+87], N[(2.0 * N[(t * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(i \cdot c\right) \cdot a\right) \cdot -2\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+102}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-90}:\\
\;\;\;\;\left(y \cdot x\right) \cdot 2\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+87}:\\
\;\;\;\;2 \cdot \left(t \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.99999999999999977e101 or 1.9999999999999999e87 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 85.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6444.2
Applied rewrites44.2%
if -9.99999999999999977e101 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 5.00000000000000019e-90Initial program 98.8%
Taylor expanded in x around inf
lower-*.f64N/A
*-commutativeN/A
lower-*.f6461.8
Applied rewrites61.8%
if 5.00000000000000019e-90 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.9999999999999999e87Initial program 99.7%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6454.3
Applied rewrites54.3%
Final simplification51.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -1e+102)
(* (fma (- i) (* (fma c b a) c) (* y x)) 2.0)
(if (<= t_1 1e+201)
(* (fma z t (fma (- (* (* i c) b)) c (* y x))) 2.0)
(* (* (* -2.0 c) i) (fma c b a))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -1e+102) {
tmp = fma(-i, (fma(c, b, a) * c), (y * x)) * 2.0;
} else if (t_1 <= 1e+201) {
tmp = fma(z, t, fma(-((i * c) * b), c, (y * x))) * 2.0;
} else {
tmp = ((-2.0 * c) * i) * fma(c, b, a);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -1e+102) tmp = Float64(fma(Float64(-i), Float64(fma(c, b, a) * c), Float64(y * x)) * 2.0); elseif (t_1 <= 1e+201) tmp = Float64(fma(z, t, fma(Float64(-Float64(Float64(i * c) * b)), c, Float64(y * x))) * 2.0); else tmp = Float64(Float64(Float64(-2.0 * c) * i) * fma(c, b, a)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+102], N[(N[((-i) * N[(N[(c * b + a), $MachinePrecision] * c), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$1, 1e+201], N[(N[(z * t + N[((-N[(N[(i * c), $MachinePrecision] * b), $MachinePrecision]) * c + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(-2.0 * c), $MachinePrecision] * i), $MachinePrecision] * N[(c * b + a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+102}:\\
\;\;\;\;\mathsf{fma}\left(-i, \mathsf{fma}\left(c, b, a\right) \cdot c, y \cdot x\right) \cdot 2\\
\mathbf{elif}\;t\_1 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(z, t, \mathsf{fma}\left(-\left(i \cdot c\right) \cdot b, c, y \cdot x\right)\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-2 \cdot c\right) \cdot i\right) \cdot \mathsf{fma}\left(c, b, a\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.99999999999999977e101Initial program 92.4%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6489.3
Applied rewrites89.3%
if -9.99999999999999977e101 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.1%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
+-commutativeN/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
Applied rewrites97.6%
Taylor expanded in a around 0
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6488.8
Applied rewrites88.8%
if 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 75.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6489.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6489.7
Applied rewrites89.7%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6478.4
Applied rewrites78.4%
Applied rewrites89.5%
Final simplification89.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -2e+42)
(* (fma (- i) (* (fma c b a) c) (* y x)) 2.0)
(if (<= t_1 1e+201)
(* (fma t z (* y x)) 2.0)
(* (* (* -2.0 c) i) (fma c b a))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -2e+42) {
tmp = fma(-i, (fma(c, b, a) * c), (y * x)) * 2.0;
} else if (t_1 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = ((-2.0 * c) * i) * fma(c, b, a);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -2e+42) tmp = Float64(fma(Float64(-i), Float64(fma(c, b, a) * c), Float64(y * x)) * 2.0); elseif (t_1 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = Float64(Float64(Float64(-2.0 * c) * i) * fma(c, b, a)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+42], N[(N[((-i) * N[(N[(c * b + a), $MachinePrecision] * c), $MachinePrecision] + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$1, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(-2.0 * c), $MachinePrecision] * i), $MachinePrecision] * N[(c * b + a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+42}:\\
\;\;\;\;\mathsf{fma}\left(-i, \mathsf{fma}\left(c, b, a\right) \cdot c, y \cdot x\right) \cdot 2\\
\mathbf{elif}\;t\_1 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-2 \cdot c\right) \cdot i\right) \cdot \mathsf{fma}\left(c, b, a\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000009e42Initial program 93.3%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6487.9
Applied rewrites87.9%
if -2.00000000000000009e42 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.1%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6485.0
Applied rewrites85.0%
if 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 75.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6489.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6489.7
Applied rewrites89.7%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6478.4
Applied rewrites78.4%
Applied rewrites89.5%
Final simplification87.0%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -1e+102)
(* (fma (- i) (* (fma c b a) c) (* t z)) 2.0)
(if (<= t_1 1e+201)
(* (fma t z (* y x)) 2.0)
(* (* (* -2.0 c) i) (fma c b a))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -1e+102) {
tmp = fma(-i, (fma(c, b, a) * c), (t * z)) * 2.0;
} else if (t_1 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = ((-2.0 * c) * i) * fma(c, b, a);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -1e+102) tmp = Float64(fma(Float64(-i), Float64(fma(c, b, a) * c), Float64(t * z)) * 2.0); elseif (t_1 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = Float64(Float64(Float64(-2.0 * c) * i) * fma(c, b, a)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+102], N[(N[((-i) * N[(N[(c * b + a), $MachinePrecision] * c), $MachinePrecision] + N[(t * z), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], If[LessEqual[t$95$1, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(-2.0 * c), $MachinePrecision] * i), $MachinePrecision] * N[(c * b + a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+102}:\\
\;\;\;\;\mathsf{fma}\left(-i, \mathsf{fma}\left(c, b, a\right) \cdot c, t \cdot z\right) \cdot 2\\
\mathbf{elif}\;t\_1 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-2 \cdot c\right) \cdot i\right) \cdot \mathsf{fma}\left(c, b, a\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -9.99999999999999977e101Initial program 92.4%
Taylor expanded in x around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6484.8
Applied rewrites84.8%
if -9.99999999999999977e101 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.1%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6483.8
Applied rewrites83.8%
if 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 75.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6489.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6489.7
Applied rewrites89.7%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6478.4
Applied rewrites78.4%
Applied rewrites89.5%
Final simplification85.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -1e+153)
(* (* (* (fma b c a) c) -2.0) i)
(if (<= t_1 1e+201)
(* (fma t z (* y x)) 2.0)
(* (* (* -2.0 c) i) (fma c b a))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -1e+153) {
tmp = ((fma(b, c, a) * c) * -2.0) * i;
} else if (t_1 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = ((-2.0 * c) * i) * fma(c, b, a);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -1e+153) tmp = Float64(Float64(Float64(fma(b, c, a) * c) * -2.0) * i); elseif (t_1 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = Float64(Float64(Float64(-2.0 * c) * i) * fma(c, b, a)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+153], N[(N[(N[(N[(b * c + a), $MachinePrecision] * c), $MachinePrecision] * -2.0), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[t$95$1, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(-2.0 * c), $MachinePrecision] * i), $MachinePrecision] * N[(c * b + a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+153}:\\
\;\;\;\;\left(\left(\mathsf{fma}\left(b, c, a\right) \cdot c\right) \cdot -2\right) \cdot i\\
\mathbf{elif}\;t\_1 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-2 \cdot c\right) \cdot i\right) \cdot \mathsf{fma}\left(c, b, a\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -1e153Initial program 91.0%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6492.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6492.6
Applied rewrites92.6%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6487.5
Applied rewrites87.5%
if -1e153 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.2%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6481.4
Applied rewrites81.4%
if 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 75.7%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6489.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6489.7
Applied rewrites89.7%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6478.4
Applied rewrites78.4%
Applied rewrites89.5%
Final simplification84.8%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -1e+153)
(* (* (* (fma b c a) c) -2.0) i)
(if (<= t_1 1e+201)
(* (fma t z (* y x)) 2.0)
(* (* (* (fma c b a) i) -2.0) c)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -1e+153) {
tmp = ((fma(b, c, a) * c) * -2.0) * i;
} else if (t_1 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = ((fma(c, b, a) * i) * -2.0) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -1e+153) tmp = Float64(Float64(Float64(fma(b, c, a) * c) * -2.0) * i); elseif (t_1 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = Float64(Float64(Float64(fma(c, b, a) * i) * -2.0) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+153], N[(N[(N[(N[(b * c + a), $MachinePrecision] * c), $MachinePrecision] * -2.0), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[t$95$1, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision] * -2.0), $MachinePrecision] * c), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+153}:\\
\;\;\;\;\left(\left(\mathsf{fma}\left(b, c, a\right) \cdot c\right) \cdot -2\right) \cdot i\\
\mathbf{elif}\;t\_1 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\mathsf{fma}\left(c, b, a\right) \cdot i\right) \cdot -2\right) \cdot c\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -1e153Initial program 91.0%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
clear-numN/A
flip3-+N/A
lift-+.f64N/A
lower-/.f6492.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6492.6
Applied rewrites92.6%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6487.5
Applied rewrites87.5%
if -1e153 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.2%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6481.4
Applied rewrites81.4%
if 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 75.7%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6484.5
Applied rewrites84.5%
Final simplification83.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* (* (fma c b a) i) -2.0) c)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+153)
t_1
(if (<= t_2 1e+201) (* (fma t z (* y x)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = ((fma(c, b, a) * i) * -2.0) * c;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+153) {
tmp = t_1;
} else if (t_2 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(fma(c, b, a) * i) * -2.0) * c) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+153) tmp = t_1; elseif (t_2 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(N[(c * b + a), $MachinePrecision] * i), $MachinePrecision] * -2.0), $MachinePrecision] * c), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+153], t$95$1, If[LessEqual[t$95$2, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(\mathsf{fma}\left(c, b, a\right) \cdot i\right) \cdot -2\right) \cdot c\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+153}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -1e153 or 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 82.5%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6484.3
Applied rewrites84.3%
if -1e153 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.2%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6481.4
Applied rewrites81.4%
Final simplification82.8%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* (* (* c c) i) b) -2.0)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+154)
t_1
(if (<= t_2 1e+201) (* (fma t z (* y x)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (((c * c) * i) * b) * -2.0;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+154) {
tmp = t_1;
} else if (t_2 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(Float64(c * c) * i) * b) * -2.0) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+154) tmp = t_1; elseif (t_2 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(N[(c * c), $MachinePrecision] * i), $MachinePrecision] * b), $MachinePrecision] * -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+154], t$95$1, If[LessEqual[t$95$2, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(\left(c \cdot c\right) \cdot i\right) \cdot b\right) \cdot -2\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+154}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -1.00000000000000004e154 or 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 82.3%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6490.9
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6490.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6490.9
Applied rewrites90.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6464.4
Applied rewrites64.4%
if -1.00000000000000004e154 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.2%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6480.9
Applied rewrites80.9%
Final simplification73.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* i (* (+ (* c b) a) c))))
(if (<= t_1 -5e+199)
(* (* (* (* i b) c) c) -2.0)
(if (<= t_1 1e+201)
(* (fma t z (* y x)) 2.0)
(* (* (* i c) (* c b)) -2.0)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = i * (((c * b) + a) * c);
double tmp;
if (t_1 <= -5e+199) {
tmp = (((i * b) * c) * c) * -2.0;
} else if (t_1 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = ((i * c) * (c * b)) * -2.0;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_1 <= -5e+199) tmp = Float64(Float64(Float64(Float64(i * b) * c) * c) * -2.0); elseif (t_1 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = Float64(Float64(Float64(i * c) * Float64(c * b)) * -2.0); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+199], N[(N[(N[(N[(i * b), $MachinePrecision] * c), $MachinePrecision] * c), $MachinePrecision] * -2.0), $MachinePrecision], If[LessEqual[t$95$1, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], N[(N[(N[(i * c), $MachinePrecision] * N[(c * b), $MachinePrecision]), $MachinePrecision] * -2.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+199}:\\
\;\;\;\;\left(\left(\left(i \cdot b\right) \cdot c\right) \cdot c\right) \cdot -2\\
\mathbf{elif}\;t\_1 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;\left(\left(i \cdot c\right) \cdot \left(c \cdot b\right)\right) \cdot -2\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.9999999999999998e199Initial program 90.0%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6492.0
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6492.0
lift-*.f64N/A
*-commutativeN/A
lower-*.f6492.0
Applied rewrites92.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6469.7
Applied rewrites69.7%
Applied rewrites67.7%
if -4.9999999999999998e199 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.2%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6479.3
Applied rewrites79.3%
if 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 75.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6489.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6489.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6489.6
Applied rewrites89.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6462.8
Applied rewrites62.8%
Applied rewrites61.2%
Final simplification72.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* (* (* i b) c) c) -2.0)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -5e+199)
t_1
(if (<= t_2 1e+201) (* (fma t z (* y x)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (((i * b) * c) * c) * -2.0;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -5e+199) {
tmp = t_1;
} else if (t_2 <= 1e+201) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(Float64(i * b) * c) * c) * -2.0) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -5e+199) tmp = t_1; elseif (t_2 <= 1e+201) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(N[(i * b), $MachinePrecision] * c), $MachinePrecision] * c), $MachinePrecision] * -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+199], t$95$1, If[LessEqual[t$95$2, 1e+201], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(\left(i \cdot b\right) \cdot c\right) \cdot c\right) \cdot -2\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+199}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 10^{+201}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.9999999999999998e199 or 1.00000000000000004e201 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 81.7%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6490.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6490.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6490.6
Applied rewrites90.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6465.7
Applied rewrites65.7%
Applied rewrites62.0%
if -4.9999999999999998e199 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000004e201Initial program 99.2%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6479.3
Applied rewrites79.3%
Final simplification71.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* (* i c) a) -2.0)) (t_2 (* i (* (+ (* c b) a) c))))
(if (<= t_2 -1e+153)
t_1
(if (<= t_2 5e+212) (* (fma t z (* y x)) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = ((i * c) * a) * -2.0;
double t_2 = i * (((c * b) + a) * c);
double tmp;
if (t_2 <= -1e+153) {
tmp = t_1;
} else if (t_2 <= 5e+212) {
tmp = fma(t, z, (y * x)) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(i * c) * a) * -2.0) t_2 = Float64(i * Float64(Float64(Float64(c * b) + a) * c)) tmp = 0.0 if (t_2 <= -1e+153) tmp = t_1; elseif (t_2 <= 5e+212) tmp = Float64(fma(t, z, Float64(y * x)) * 2.0); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(i * c), $MachinePrecision] * a), $MachinePrecision] * -2.0), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(N[(c * b), $MachinePrecision] + a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+153], t$95$1, If[LessEqual[t$95$2, 5e+212], N[(N[(t * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(i \cdot c\right) \cdot a\right) \cdot -2\\
t_2 := i \cdot \left(\left(c \cdot b + a\right) \cdot c\right)\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+153}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+212}:\\
\;\;\;\;\mathsf{fma}\left(t, z, y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -1e153 or 4.99999999999999992e212 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 82.2%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6446.9
Applied rewrites46.9%
if -1e153 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 4.99999999999999992e212Initial program 99.2%
Taylor expanded in c around 0
lower-*.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6480.3
Applied rewrites80.3%
Final simplification64.9%
(FPCore (x y z t a b c i) :precision binary64 (* (fma z t (fma (* (- i) (fma c b a)) c (* y x))) 2.0))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return fma(z, t, fma((-i * fma(c, b, a)), c, (y * x))) * 2.0;
}
function code(x, y, z, t, a, b, c, i) return Float64(fma(z, t, fma(Float64(Float64(-i) * fma(c, b, a)), c, Float64(y * x))) * 2.0) end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(z * t + N[(N[((-i) * N[(c * b + a), $MachinePrecision]), $MachinePrecision] * c + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(z, t, \mathsf{fma}\left(\left(-i\right) \cdot \mathsf{fma}\left(c, b, a\right), c, y \cdot x\right)\right) \cdot 2
\end{array}
Initial program 91.3%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
+-commutativeN/A
sub-negN/A
associate-+l+N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
Applied rewrites93.6%
Final simplification93.6%
(FPCore (x y z t a b c i) :precision binary64 (let* ((t_1 (* 2.0 (* t z)))) (if (<= (* t z) -5e+88) t_1 (if (<= (* t z) 2e+142) (* (* y x) 2.0) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = 2.0 * (t * z);
double tmp;
if ((t * z) <= -5e+88) {
tmp = t_1;
} else if ((t * z) <= 2e+142) {
tmp = (y * x) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = 2.0d0 * (t * z)
if ((t * z) <= (-5d+88)) then
tmp = t_1
else if ((t * z) <= 2d+142) then
tmp = (y * x) * 2.0d0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = 2.0 * (t * z);
double tmp;
if ((t * z) <= -5e+88) {
tmp = t_1;
} else if ((t * z) <= 2e+142) {
tmp = (y * x) * 2.0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = 2.0 * (t * z) tmp = 0 if (t * z) <= -5e+88: tmp = t_1 elif (t * z) <= 2e+142: tmp = (y * x) * 2.0 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(2.0 * Float64(t * z)) tmp = 0.0 if (Float64(t * z) <= -5e+88) tmp = t_1; elseif (Float64(t * z) <= 2e+142) tmp = Float64(Float64(y * x) * 2.0); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = 2.0 * (t * z); tmp = 0.0; if ((t * z) <= -5e+88) tmp = t_1; elseif ((t * z) <= 2e+142) tmp = (y * x) * 2.0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(2.0 * N[(t * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t * z), $MachinePrecision], -5e+88], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], 2e+142], N[(N[(y * x), $MachinePrecision] * 2.0), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 \cdot \left(t \cdot z\right)\\
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+88}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq 2 \cdot 10^{+142}:\\
\;\;\;\;\left(y \cdot x\right) \cdot 2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -4.99999999999999997e88 or 2.0000000000000001e142 < (*.f64 z t) Initial program 90.6%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6458.7
Applied rewrites58.7%
if -4.99999999999999997e88 < (*.f64 z t) < 2.0000000000000001e142Initial program 91.7%
Taylor expanded in x around inf
lower-*.f64N/A
*-commutativeN/A
lower-*.f6439.7
Applied rewrites39.7%
Final simplification45.9%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (* t z)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (t * z);
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = 2.0d0 * (t * z)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (t * z);
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (t * z)
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(t * z)) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (t * z); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(t * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(t \cdot z\right)
\end{array}
Initial program 91.3%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6424.0
Applied rewrites24.0%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (- (+ (* x y) (* z t)) (* (+ a (* b c)) (* c i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)));
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
code = 2.0d0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)));
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i)))
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(a + Float64(b * c)) * Float64(c * i)))) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (((x * y) + (z * t)) - ((a + (b * c)) * (c * i))); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision] * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(\left(x \cdot y + z \cdot t\right) - \left(a + b \cdot c\right) \cdot \left(c \cdot i\right)\right)
\end{array}
herbie shell --seed 2024332
(FPCore (x y z t a b c i)
:name "Diagrams.ThreeD.Shapes:frustum from diagrams-lib-1.3.0.3, A"
:precision binary64
:alt
(! :herbie-platform default (* 2 (- (+ (* x y) (* z t)) (* (+ a (* b c)) (* c i)))))
(* 2.0 (- (+ (* x y) (* z t)) (* (* (+ a (* b c)) c) i))))