
(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 21 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 (<= (- (+ (* x y) (* z t)) (* (* c (+ a (* b c))) i)) 1e+272) (* 2.0 (fma (fma b c a) (* c (- i)) (fma z t (* x y)))) (* 2.0 (fma z t (fma y x (* (* i (fma c b a)) (- c)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((((x * y) + (z * t)) - ((c * (a + (b * c))) * i)) <= 1e+272) {
tmp = 2.0 * fma(fma(b, c, a), (c * -i), fma(z, t, (x * y)));
} else {
tmp = 2.0 * fma(z, t, fma(y, x, ((i * fma(c, b, a)) * -c)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(c * Float64(a + Float64(b * c))) * i)) <= 1e+272) tmp = Float64(2.0 * fma(fma(b, c, a), Float64(c * Float64(-i)), fma(z, t, Float64(x * y)))); else tmp = Float64(2.0 * fma(z, t, fma(y, x, Float64(Float64(i * fma(c, b, a)) * Float64(-c))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision], 1e+272], N[(2.0 * N[(N[(b * c + a), $MachinePrecision] * N[(c * (-i)), $MachinePrecision] + N[(z * t + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(z * t + N[(y * x + N[(N[(i * N[(c * b + a), $MachinePrecision]), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(x \cdot y + z \cdot t\right) - \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i \leq 10^{+272}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(\mathsf{fma}\left(b, c, a\right), c \cdot \left(-i\right), \mathsf{fma}\left(z, t, x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(z, t, \mathsf{fma}\left(y, x, \left(i \cdot \mathsf{fma}\left(c, b, a\right)\right) \cdot \left(-c\right)\right)\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) < 1.0000000000000001e272Initial program 98.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.3
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.3
Applied rewrites99.3%
if 1.0000000000000001e272 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) Initial program 77.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6490.5
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6493.6
Applied rewrites93.6%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
associate-+l+N/A
lower-fma.f64N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
Applied rewrites87.1%
lift-fma.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-outN/A
distribute-rgt-neg-inN/A
lift-fma.f64N/A
+-commutativeN/A
associate-*l*N/A
lower-neg.f64N/A
+-commutativeN/A
lift-fma.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6498.9
Applied rewrites98.9%
Final simplification99.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* c (- i)))
(t_2 (* 2.0 (fma (fma b c a) t_1 (* x y))))
(t_3 (* (* c (+ a (* b c))) i)))
(if (<= t_3 -5e+27)
t_2
(if (<= t_3 1e-179)
(* 2.0 (fma (* b c) t_1 (fma z t (* x y))))
(if (<= t_3 5e-18) (* 2.0 (- (* z t) (* c (* i (fma b c a))))) t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = c * -i;
double t_2 = 2.0 * fma(fma(b, c, a), t_1, (x * y));
double t_3 = (c * (a + (b * c))) * i;
double tmp;
if (t_3 <= -5e+27) {
tmp = t_2;
} else if (t_3 <= 1e-179) {
tmp = 2.0 * fma((b * c), t_1, fma(z, t, (x * y)));
} else if (t_3 <= 5e-18) {
tmp = 2.0 * ((z * t) - (c * (i * fma(b, c, a))));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(c * Float64(-i)) t_2 = Float64(2.0 * fma(fma(b, c, a), t_1, Float64(x * y))) t_3 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_3 <= -5e+27) tmp = t_2; elseif (t_3 <= 1e-179) tmp = Float64(2.0 * fma(Float64(b * c), t_1, fma(z, t, Float64(x * y)))); elseif (t_3 <= 5e-18) tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(i * fma(b, c, a))))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(c * (-i)), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 * N[(N[(b * c + a), $MachinePrecision] * t$95$1 + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$3, -5e+27], t$95$2, If[LessEqual[t$95$3, 1e-179], N[(2.0 * N[(N[(b * c), $MachinePrecision] * t$95$1 + N[(z * t + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 5e-18], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(-i\right)\\
t_2 := 2 \cdot \mathsf{fma}\left(\mathsf{fma}\left(b, c, a\right), t\_1, x \cdot y\right)\\
t_3 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+27}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq 10^{-179}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(b \cdot c, t\_1, \mathsf{fma}\left(z, t, x \cdot y\right)\right)\\
\mathbf{elif}\;t\_3 \leq 5 \cdot 10^{-18}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(i \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.99999999999999979e27 or 5.00000000000000036e-18 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 86.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6495.3
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6495.9
Applied rewrites95.9%
Taylor expanded in z around 0
lower-*.f6490.9
Applied rewrites90.9%
if -4.99999999999999979e27 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e-179Initial program 97.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f64100.0
Applied rewrites100.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f6496.1
Applied rewrites96.1%
if 1e-179 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 5.00000000000000036e-18Initial program 99.7%
Taylor expanded in x around 0
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
Final simplification93.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* 2.0 (fma (fma b c a) (* c (- i)) (* x y))))
(t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -5e+27)
t_1
(if (<= t_2 1e-179)
(* 2.0 (fma z t (fma y x (* (* i (* b c)) (- c)))))
(if (<= t_2 5e-18) (* 2.0 (- (* z t) (* c (* i (fma b c a))))) 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 * fma(fma(b, c, a), (c * -i), (x * y));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -5e+27) {
tmp = t_1;
} else if (t_2 <= 1e-179) {
tmp = 2.0 * fma(z, t, fma(y, x, ((i * (b * c)) * -c)));
} else if (t_2 <= 5e-18) {
tmp = 2.0 * ((z * t) - (c * (i * fma(b, c, a))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(2.0 * fma(fma(b, c, a), Float64(c * Float64(-i)), Float64(x * y))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -5e+27) tmp = t_1; elseif (t_2 <= 1e-179) tmp = Float64(2.0 * fma(z, t, fma(y, x, Float64(Float64(i * Float64(b * c)) * Float64(-c))))); elseif (t_2 <= 5e-18) tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(i * fma(b, c, a))))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(2.0 * N[(N[(b * c + a), $MachinePrecision] * N[(c * (-i)), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+27], t$95$1, If[LessEqual[t$95$2, 1e-179], N[(2.0 * N[(z * t + N[(y * x + N[(N[(i * N[(b * c), $MachinePrecision]), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e-18], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 \cdot \mathsf{fma}\left(\mathsf{fma}\left(b, c, a\right), c \cdot \left(-i\right), x \cdot y\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+27}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 10^{-179}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(z, t, \mathsf{fma}\left(y, x, \left(i \cdot \left(b \cdot c\right)\right) \cdot \left(-c\right)\right)\right)\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-18}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(i \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.99999999999999979e27 or 5.00000000000000036e-18 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 86.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6495.3
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6495.9
Applied rewrites95.9%
Taylor expanded in z around 0
lower-*.f6490.9
Applied rewrites90.9%
if -4.99999999999999979e27 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e-179Initial program 97.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6497.7
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f64100.0
Applied rewrites100.0%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
associate-+l+N/A
lower-fma.f64N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
Applied rewrites100.0%
lift-fma.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-outN/A
distribute-rgt-neg-inN/A
lift-fma.f64N/A
+-commutativeN/A
associate-*l*N/A
lower-neg.f64N/A
+-commutativeN/A
lift-fma.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6498.8
Applied rewrites98.8%
Taylor expanded in c around inf
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6496.1
Applied rewrites96.1%
if 1e-179 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 5.00000000000000036e-18Initial program 99.7%
Taylor expanded in x around 0
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
Final simplification93.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* 2.0 (fma (fma b c a) (* c (- i)) (* x y))))
(t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -5e+27)
t_1
(if (<= t_2 1e-179)
(* 2.0 (fma t z (* x y)))
(if (<= t_2 5e-18) (* 2.0 (- (* z t) (* c (* i (fma b c a))))) 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 * fma(fma(b, c, a), (c * -i), (x * y));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -5e+27) {
tmp = t_1;
} else if (t_2 <= 1e-179) {
tmp = 2.0 * fma(t, z, (x * y));
} else if (t_2 <= 5e-18) {
tmp = 2.0 * ((z * t) - (c * (i * fma(b, c, a))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(2.0 * fma(fma(b, c, a), Float64(c * Float64(-i)), Float64(x * y))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -5e+27) tmp = t_1; elseif (t_2 <= 1e-179) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); elseif (t_2 <= 5e-18) tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(i * fma(b, c, a))))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(2.0 * N[(N[(b * c + a), $MachinePrecision] * N[(c * (-i)), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+27], t$95$1, If[LessEqual[t$95$2, 1e-179], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e-18], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 \cdot \mathsf{fma}\left(\mathsf{fma}\left(b, c, a\right), c \cdot \left(-i\right), x \cdot y\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+27}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 10^{-179}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-18}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(i \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.99999999999999979e27 or 5.00000000000000036e-18 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 86.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6495.3
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6495.9
Applied rewrites95.9%
Taylor expanded in z around 0
lower-*.f6490.9
Applied rewrites90.9%
if -4.99999999999999979e27 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e-179Initial program 97.7%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6496.1
Applied rewrites96.1%
if 1e-179 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 5.00000000000000036e-18Initial program 99.7%
Taylor expanded in x around 0
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
Final simplification93.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* c (* i (fma b c a)))) (t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -2e+95)
(* (fma c b a) (* i (* c -2.0)))
(if (<= t_2 1e-179)
(* 2.0 (fma t z (* x y)))
(if (<= t_2 5e-18) (* 2.0 (- (* z t) t_1)) (* 2.0 (- (* x y) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = c * (i * fma(b, c, a));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -2e+95) {
tmp = fma(c, b, a) * (i * (c * -2.0));
} else if (t_2 <= 1e-179) {
tmp = 2.0 * fma(t, z, (x * y));
} else if (t_2 <= 5e-18) {
tmp = 2.0 * ((z * t) - t_1);
} else {
tmp = 2.0 * ((x * y) - t_1);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(c * Float64(i * fma(b, c, a))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -2e+95) tmp = Float64(fma(c, b, a) * Float64(i * Float64(c * -2.0))); elseif (t_2 <= 1e-179) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); elseif (t_2 <= 5e-18) tmp = Float64(2.0 * Float64(Float64(z * t) - t_1)); else tmp = Float64(2.0 * Float64(Float64(x * y) - t_1)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(c * N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+95], N[(N[(c * b + a), $MachinePrecision] * N[(i * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e-179], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e-18], N[(2.0 * N[(N[(z * t), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(x * y), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(i \cdot \mathsf{fma}\left(b, c, a\right)\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(c, b, a\right) \cdot \left(i \cdot \left(c \cdot -2\right)\right)\\
\mathbf{elif}\;t\_2 \leq 10^{-179}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-18}:\\
\;\;\;\;2 \cdot \left(z \cdot t - t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(x \cdot y - t\_1\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000004e95Initial program 83.2%
Taylor expanded in b around inf
mul-1-negN/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-outN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
unpow2N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6450.0
Applied rewrites50.0%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6450.0
Applied rewrites51.3%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6480.2
Applied rewrites80.2%
Applied rewrites88.9%
if -2.00000000000000004e95 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e-179Initial program 97.8%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6494.2
Applied rewrites94.2%
if 1e-179 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 5.00000000000000036e-18Initial program 99.7%
Taylor expanded in x around 0
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
if 5.00000000000000036e-18 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 88.6%
Taylor expanded in z around 0
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6485.4
Applied rewrites85.4%
Final simplification90.7%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* c (* b (* i (* c -2.0))))) (t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -2e+286)
t_1
(if (<= t_2 2e+161)
(* 2.0 (fma t z (* x y)))
(if (<= t_2 1e+284) (* a (* -2.0 (* c i))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = c * (b * (i * (c * -2.0)));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -2e+286) {
tmp = t_1;
} else if (t_2 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else if (t_2 <= 1e+284) {
tmp = a * (-2.0 * (c * i));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(c * Float64(b * Float64(i * Float64(c * -2.0)))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -2e+286) tmp = t_1; elseif (t_2 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); elseif (t_2 <= 1e+284) tmp = Float64(a * Float64(-2.0 * Float64(c * i))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(c * N[(b * N[(i * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+286], t$95$1, If[LessEqual[t$95$2, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+284], N[(a * N[(-2.0 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(b \cdot \left(i \cdot \left(c \cdot -2\right)\right)\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+286}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{elif}\;t\_2 \leq 10^{+284}:\\
\;\;\;\;a \cdot \left(-2 \cdot \left(c \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000007e286 or 1.00000000000000008e284 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 79.0%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6471.1
Applied rewrites71.1%
Applied rewrites68.4%
Applied rewrites72.9%
if -2.00000000000000007e286 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.5%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6479.5
Applied rewrites79.5%
if 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000008e284Initial program 99.4%
Taylor expanded in z around inf
lower-*.f6410.5
Applied rewrites10.5%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.2
Applied rewrites62.2%
Final simplification76.0%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* c (+ a (* b c))) i)))
(if (<= t_1 -2e+286)
(* c (* c (* i (* b -2.0))))
(if (<= t_1 2e+161)
(* 2.0 (fma t z (* x y)))
(if (<= t_1 1e+284)
(* a (* -2.0 (* c i)))
(* (* i -2.0) (* c (* b c))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (c * (a + (b * c))) * i;
double tmp;
if (t_1 <= -2e+286) {
tmp = c * (c * (i * (b * -2.0)));
} else if (t_1 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else if (t_1 <= 1e+284) {
tmp = a * (-2.0 * (c * i));
} else {
tmp = (i * -2.0) * (c * (b * c));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_1 <= -2e+286) tmp = Float64(c * Float64(c * Float64(i * Float64(b * -2.0)))); elseif (t_1 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); elseif (t_1 <= 1e+284) tmp = Float64(a * Float64(-2.0 * Float64(c * i))); else tmp = Float64(Float64(i * -2.0) * Float64(c * Float64(b * c))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+286], N[(c * N[(c * N[(i * N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+284], N[(a * N[(-2.0 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i * -2.0), $MachinePrecision] * N[(c * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+286}:\\
\;\;\;\;c \cdot \left(c \cdot \left(i \cdot \left(b \cdot -2\right)\right)\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{elif}\;t\_1 \leq 10^{+284}:\\
\;\;\;\;a \cdot \left(-2 \cdot \left(c \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot -2\right) \cdot \left(c \cdot \left(b \cdot c\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000007e286Initial program 78.5%
Taylor expanded in z around inf
lower-*.f648.4
Applied rewrites8.4%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6466.1
Applied rewrites66.1%
if -2.00000000000000007e286 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.5%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6479.5
Applied rewrites79.5%
if 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000008e284Initial program 99.4%
Taylor expanded in z around inf
lower-*.f6410.5
Applied rewrites10.5%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.2
Applied rewrites62.2%
if 1.00000000000000008e284 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 80.1%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6482.9
Applied rewrites82.9%
Applied rewrites83.0%
Final simplification75.6%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* c (+ a (* b c))) i)))
(if (<= t_1 -2e+286)
(* c (* c (* i (* b -2.0))))
(if (<= t_1 2e+161)
(* 2.0 (fma t z (* x y)))
(if (<= t_1 1e+284)
(* a (* -2.0 (* c i)))
(* b (* i (* -2.0 (* c c)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (c * (a + (b * c))) * i;
double tmp;
if (t_1 <= -2e+286) {
tmp = c * (c * (i * (b * -2.0)));
} else if (t_1 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else if (t_1 <= 1e+284) {
tmp = a * (-2.0 * (c * i));
} else {
tmp = b * (i * (-2.0 * (c * c)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_1 <= -2e+286) tmp = Float64(c * Float64(c * Float64(i * Float64(b * -2.0)))); elseif (t_1 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); elseif (t_1 <= 1e+284) tmp = Float64(a * Float64(-2.0 * Float64(c * i))); else tmp = Float64(b * Float64(i * Float64(-2.0 * Float64(c * c)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+286], N[(c * N[(c * N[(i * N[(b * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+284], N[(a * N[(-2.0 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b * N[(i * N[(-2.0 * N[(c * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+286}:\\
\;\;\;\;c \cdot \left(c \cdot \left(i \cdot \left(b \cdot -2\right)\right)\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{elif}\;t\_1 \leq 10^{+284}:\\
\;\;\;\;a \cdot \left(-2 \cdot \left(c \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(i \cdot \left(-2 \cdot \left(c \cdot c\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000007e286Initial program 78.5%
Taylor expanded in z around inf
lower-*.f648.4
Applied rewrites8.4%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6466.1
Applied rewrites66.1%
if -2.00000000000000007e286 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.5%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6479.5
Applied rewrites79.5%
if 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000008e284Initial program 99.4%
Taylor expanded in z around inf
lower-*.f6410.5
Applied rewrites10.5%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.2
Applied rewrites62.2%
if 1.00000000000000008e284 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 80.1%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6482.9
Applied rewrites82.9%
Final simplification75.6%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* b (* i (* -2.0 (* c c))))) (t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -2e+286)
t_1
(if (<= t_2 2e+161)
(* 2.0 (fma t z (* x y)))
(if (<= t_2 1e+284) (* a (* -2.0 (* c i))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = b * (i * (-2.0 * (c * c)));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -2e+286) {
tmp = t_1;
} else if (t_2 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else if (t_2 <= 1e+284) {
tmp = a * (-2.0 * (c * i));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(b * Float64(i * Float64(-2.0 * Float64(c * c)))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -2e+286) tmp = t_1; elseif (t_2 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); elseif (t_2 <= 1e+284) tmp = Float64(a * Float64(-2.0 * Float64(c * i))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(b * N[(i * N[(-2.0 * N[(c * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+286], t$95$1, If[LessEqual[t$95$2, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+284], N[(a * N[(-2.0 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(i \cdot \left(-2 \cdot \left(c \cdot c\right)\right)\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+286}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{elif}\;t\_2 \leq 10^{+284}:\\
\;\;\;\;a \cdot \left(-2 \cdot \left(c \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000007e286 or 1.00000000000000008e284 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 79.0%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6471.1
Applied rewrites71.1%
if -2.00000000000000007e286 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.5%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6479.5
Applied rewrites79.5%
if 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000008e284Initial program 99.4%
Taylor expanded in z around inf
lower-*.f6410.5
Applied rewrites10.5%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.2
Applied rewrites62.2%
Final simplification75.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* c (+ a (* b c))) i)))
(if (<= t_1 -2e+95)
(* (fma c b a) (* i (* c -2.0)))
(if (<= t_1 1e-179)
(* 2.0 (fma t z (* x y)))
(* 2.0 (- (* z t) (* c (* i (fma b c a)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (c * (a + (b * c))) * i;
double tmp;
if (t_1 <= -2e+95) {
tmp = fma(c, b, a) * (i * (c * -2.0));
} else if (t_1 <= 1e-179) {
tmp = 2.0 * fma(t, z, (x * y));
} else {
tmp = 2.0 * ((z * t) - (c * (i * fma(b, c, a))));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_1 <= -2e+95) tmp = Float64(fma(c, b, a) * Float64(i * Float64(c * -2.0))); elseif (t_1 <= 1e-179) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); else tmp = Float64(2.0 * Float64(Float64(z * t) - Float64(c * Float64(i * fma(b, c, a))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+95], N[(N[(c * b + a), $MachinePrecision] * N[(i * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e-179], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(z * t), $MachinePrecision] - N[(c * N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(c, b, a\right) \cdot \left(i \cdot \left(c \cdot -2\right)\right)\\
\mathbf{elif}\;t\_1 \leq 10^{-179}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(z \cdot t - c \cdot \left(i \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000004e95Initial program 83.2%
Taylor expanded in b around inf
mul-1-negN/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-outN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
unpow2N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6450.0
Applied rewrites50.0%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6450.0
Applied rewrites51.3%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6480.2
Applied rewrites80.2%
Applied rewrites88.9%
if -2.00000000000000004e95 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1e-179Initial program 97.8%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6494.2
Applied rewrites94.2%
if 1e-179 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 91.1%
Taylor expanded in x around 0
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6480.5
Applied rewrites80.5%
Final simplification88.1%
(FPCore (x y z t a b c i) :precision binary64 (if (<= (- (+ (* x y) (* z t)) (* (* c (+ a (* b c))) i)) 1e+272) (* 2.0 (fma z t (fma x y (* (- i) (* c (fma b c a)))))) (* 2.0 (fma z t (fma y x (* (* i (fma c b a)) (- c)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((((x * y) + (z * t)) - ((c * (a + (b * c))) * i)) <= 1e+272) {
tmp = 2.0 * fma(z, t, fma(x, y, (-i * (c * fma(b, c, a)))));
} else {
tmp = 2.0 * fma(z, t, fma(y, x, ((i * fma(c, b, a)) * -c)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(c * Float64(a + Float64(b * c))) * i)) <= 1e+272) tmp = Float64(2.0 * fma(z, t, fma(x, y, Float64(Float64(-i) * Float64(c * fma(b, c, a)))))); else tmp = Float64(2.0 * fma(z, t, fma(y, x, Float64(Float64(i * fma(c, b, a)) * Float64(-c))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision], 1e+272], N[(2.0 * N[(z * t + N[(x * y + N[((-i) * N[(c * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(z * t + N[(y * x + N[(N[(i * N[(c * b + a), $MachinePrecision]), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(x \cdot y + z \cdot t\right) - \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i \leq 10^{+272}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(z, t, \mathsf{fma}\left(x, y, \left(-i\right) \cdot \left(c \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(z, t, \mathsf{fma}\left(y, x, \left(i \cdot \mathsf{fma}\left(c, b, a\right)\right) \cdot \left(-c\right)\right)\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) < 1.0000000000000001e272Initial program 98.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.3
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.3
Applied rewrites99.3%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
associate-+l+N/A
lower-fma.f64N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
Applied rewrites98.7%
if 1.0000000000000001e272 < (-.f64 (+.f64 (*.f64 x y) (*.f64 z t)) (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i)) Initial program 77.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6490.5
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6493.6
Applied rewrites93.6%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
associate-+l+N/A
lower-fma.f64N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
Applied rewrites87.1%
lift-fma.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-outN/A
distribute-rgt-neg-inN/A
lift-fma.f64N/A
+-commutativeN/A
associate-*l*N/A
lower-neg.f64N/A
+-commutativeN/A
lift-fma.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6498.9
Applied rewrites98.9%
Final simplification98.8%
(FPCore (x y z t a b c i) :precision binary64 (if (<= (- (+ (* x y) (* z t)) (* (* c (+ a (* b c))) i)) INFINITY) (* 2.0 (fma y x (- (* z t) (* c (* i (fma b c a)))))) (* 2.0 (fma z t (fma y x (* (* i (* b c)) (- c)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((((x * y) + (z * t)) - ((c * (a + (b * c))) * i)) <= ((double) INFINITY)) {
tmp = 2.0 * fma(y, x, ((z * t) - (c * (i * fma(b, c, a)))));
} else {
tmp = 2.0 * fma(z, t, fma(y, x, ((i * (b * c)) * -c)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (Float64(Float64(Float64(x * y) + Float64(z * t)) - Float64(Float64(c * Float64(a + Float64(b * c))) * i)) <= Inf) tmp = Float64(2.0 * fma(y, x, Float64(Float64(z * t) - Float64(c * Float64(i * fma(b, c, a)))))); else tmp = Float64(2.0 * fma(z, t, fma(y, x, Float64(Float64(i * Float64(b * c)) * Float64(-c))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[N[(N[(N[(x * y), $MachinePrecision] + N[(z * t), $MachinePrecision]), $MachinePrecision] - N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision], Infinity], N[(2.0 * N[(y * x + N[(N[(z * t), $MachinePrecision] - N[(c * N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(z * t + N[(y * x + N[(N[(i * N[(b * c), $MachinePrecision]), $MachinePrecision] * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(x \cdot y + z \cdot t\right) - \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i \leq \infty:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(y, x, z \cdot t - c \cdot \left(i \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(z, t, \mathsf{fma}\left(y, x, \left(i \cdot \left(b \cdot c\right)\right) \cdot \left(-c\right)\right)\right)\\
\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 95.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.5
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.5
Applied rewrites99.5%
lift-fma.f64N/A
lift-fma.f64N/A
associate-+r+N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites95.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%
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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6418.2
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6445.5
Applied rewrites45.5%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
associate-+l+N/A
lower-fma.f64N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
Applied rewrites81.8%
lift-fma.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-outN/A
distribute-rgt-neg-inN/A
lift-fma.f64N/A
+-commutativeN/A
associate-*l*N/A
lower-neg.f64N/A
+-commutativeN/A
lift-fma.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6490.9
Applied rewrites90.9%
Taylor expanded in c around inf
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6490.9
Applied rewrites90.9%
Final simplification95.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (fma c b a) (* i (* c -2.0)))) (t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -2e+95)
t_1
(if (<= t_2 2e+161) (* 2.0 (fma t z (* x y))) 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 * (c * -2.0));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -2e+95) {
tmp = t_1;
} else if (t_2 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(fma(c, b, a) * Float64(i * Float64(c * -2.0))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -2e+95) tmp = t_1; elseif (t_2 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * b + a), $MachinePrecision] * N[(i * N[(c * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+95], t$95$1, If[LessEqual[t$95$2, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(c, b, a\right) \cdot \left(i \cdot \left(c \cdot -2\right)\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+95}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000004e95 or 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 84.0%
Taylor expanded in b around inf
mul-1-negN/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-outN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
unpow2N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6455.4
Applied rewrites55.4%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6455.4
Applied rewrites56.2%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6482.1
Applied rewrites82.1%
Applied rewrites88.4%
if -2.00000000000000004e95 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.3%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
Final simplification87.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* (* c (+ a (* b c))) i)))
(if (<= t_1 -2e+95)
(* c (* i (* (fma b c a) -2.0)))
(if (<= t_1 2e+161)
(* 2.0 (fma t z (* x y)))
(* i (* -2.0 (* c (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 = (c * (a + (b * c))) * i;
double tmp;
if (t_1 <= -2e+95) {
tmp = c * (i * (fma(b, c, a) * -2.0));
} else if (t_1 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else {
tmp = i * (-2.0 * (c * fma(c, b, a)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_1 <= -2e+95) tmp = Float64(c * Float64(i * Float64(fma(b, c, a) * -2.0))); elseif (t_1 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); else tmp = Float64(i * Float64(-2.0 * Float64(c * fma(c, b, a)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+95], N[(c * N[(i * N[(N[(b * c + a), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(-2.0 * N[(c * N[(c * b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+95}:\\
\;\;\;\;c \cdot \left(i \cdot \left(\mathsf{fma}\left(b, c, a\right) \cdot -2\right)\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(-2 \cdot \left(c \cdot \mathsf{fma}\left(c, b, a\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000004e95Initial program 83.2%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
associate-*r*N/A
distribute-lft-outN/A
*-commutativeN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6484.5
Applied rewrites84.5%
if -2.00000000000000004e95 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.3%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
if 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 85.4%
Taylor expanded in b around inf
mul-1-negN/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-outN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
unpow2N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6465.0
Applied rewrites65.0%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6465.0
Applied rewrites65.0%
Taylor expanded in i around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6485.5
Applied rewrites85.5%
Final simplification85.6%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* c (* i (* (fma b c a) -2.0)))) (t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -2e+95)
t_1
(if (<= t_2 2e+161) (* 2.0 (fma t z (* x y))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = c * (i * (fma(b, c, a) * -2.0));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -2e+95) {
tmp = t_1;
} else if (t_2 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(c * Float64(i * Float64(fma(b, c, a) * -2.0))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -2e+95) tmp = t_1; elseif (t_2 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(c * N[(i * N[(N[(b * c + a), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+95], t$95$1, If[LessEqual[t$95$2, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(i \cdot \left(\mathsf{fma}\left(b, c, a\right) \cdot -2\right)\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+95}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000004e95 or 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 84.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
*-commutativeN/A
lower-*.f64N/A
distribute-lft-outN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6483.5
Applied rewrites83.5%
if -2.00000000000000004e95 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.3%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6486.4
Applied rewrites86.4%
Final simplification84.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* a (* -2.0 (* c i)))) (t_2 (* (* c (+ a (* b c))) i)))
(if (<= t_2 -5e+111)
t_1
(if (<= t_2 2e+161) (* 2.0 (fma t z (* x y))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a * (-2.0 * (c * i));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -5e+111) {
tmp = t_1;
} else if (t_2 <= 2e+161) {
tmp = 2.0 * fma(t, z, (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a * Float64(-2.0 * Float64(c * i))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -5e+111) tmp = t_1; elseif (t_2 <= 2e+161) tmp = Float64(2.0 * fma(t, z, Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a * N[(-2.0 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+111], t$95$1, If[LessEqual[t$95$2, 2e+161], N[(2.0 * N[(t * z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(-2 \cdot \left(c \cdot i\right)\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+111}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(t, z, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.9999999999999997e111 or 2.0000000000000001e161 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 83.4%
Taylor expanded in z around inf
lower-*.f649.3
Applied rewrites9.3%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6450.7
Applied rewrites50.7%
if -4.9999999999999997e111 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 2.0000000000000001e161Initial program 98.4%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f6484.6
Applied rewrites84.6%
Final simplification67.7%
(FPCore (x y z t a b c i) :precision binary64 (let* ((t_1 (* a (* -2.0 (* c i)))) (t_2 (* (* c (+ a (* b c))) i))) (if (<= t_2 -5e+27) t_1 (if (<= t_2 1e+122) (* 2.0 (* z t)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a * (-2.0 * (c * i));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -5e+27) {
tmp = t_1;
} else if (t_2 <= 1e+122) {
tmp = 2.0 * (z * t);
} 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 = a * ((-2.0d0) * (c * i))
t_2 = (c * (a + (b * c))) * i
if (t_2 <= (-5d+27)) then
tmp = t_1
else if (t_2 <= 1d+122) then
tmp = 2.0d0 * (z * t)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = a * (-2.0 * (c * i));
double t_2 = (c * (a + (b * c))) * i;
double tmp;
if (t_2 <= -5e+27) {
tmp = t_1;
} else if (t_2 <= 1e+122) {
tmp = 2.0 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = a * (-2.0 * (c * i)) t_2 = (c * (a + (b * c))) * i tmp = 0 if t_2 <= -5e+27: tmp = t_1 elif t_2 <= 1e+122: tmp = 2.0 * (z * t) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(a * Float64(-2.0 * Float64(c * i))) t_2 = Float64(Float64(c * Float64(a + Float64(b * c))) * i) tmp = 0.0 if (t_2 <= -5e+27) tmp = t_1; elseif (t_2 <= 1e+122) tmp = Float64(2.0 * Float64(z * t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = a * (-2.0 * (c * i)); t_2 = (c * (a + (b * c))) * i; tmp = 0.0; if (t_2 <= -5e+27) tmp = t_1; elseif (t_2 <= 1e+122) tmp = 2.0 * (z * t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(a * N[(-2.0 * N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+27], t$95$1, If[LessEqual[t$95$2, 1e+122], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(-2 \cdot \left(c \cdot i\right)\right)\\
t_2 := \left(c \cdot \left(a + b \cdot c\right)\right) \cdot i\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+27}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 10^{+122}:\\
\;\;\;\;2 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -4.99999999999999979e27 or 1.00000000000000001e122 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 84.9%
Taylor expanded in z around inf
lower-*.f6410.0
Applied rewrites10.0%
Taylor expanded in a around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6449.0
Applied rewrites49.0%
if -4.99999999999999979e27 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < 1.00000000000000001e122Initial program 98.2%
Taylor expanded in z around inf
lower-*.f6452.6
Applied rewrites52.6%
Final simplification50.6%
(FPCore (x y z t a b c i) :precision binary64 (if (<= (* (* c (+ a (* b c))) i) -2e+306) (* 2.0 (fma y x (- (* z t) (* c (* i (fma b c a)))))) (* 2.0 (fma z t (fma x y (* (- i) (* c (fma b c a))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (((c * (a + (b * c))) * i) <= -2e+306) {
tmp = 2.0 * fma(y, x, ((z * t) - (c * (i * fma(b, c, a)))));
} else {
tmp = 2.0 * fma(z, t, fma(x, y, (-i * (c * fma(b, c, a)))));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (Float64(Float64(c * Float64(a + Float64(b * c))) * i) <= -2e+306) tmp = Float64(2.0 * fma(y, x, Float64(Float64(z * t) - Float64(c * Float64(i * fma(b, c, a)))))); else tmp = Float64(2.0 * fma(z, t, fma(x, y, Float64(Float64(-i) * Float64(c * fma(b, c, a)))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[N[(N[(c * N[(a + N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision], -2e+306], N[(2.0 * N[(y * x + N[(N[(z * t), $MachinePrecision] - N[(c * N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(z * t + N[(x * y + N[((-i) * N[(c * N[(b * c + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(c \cdot \left(a + b \cdot c\right)\right) \cdot i \leq -2 \cdot 10^{+306}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(y, x, z \cdot t - c \cdot \left(i \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \mathsf{fma}\left(z, t, \mathsf{fma}\left(x, y, \left(-i\right) \cdot \left(c \cdot \mathsf{fma}\left(b, c, a\right)\right)\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) < -2.00000000000000003e306Initial program 78.1%
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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6493.8
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6495.3
Applied rewrites95.3%
lift-fma.f64N/A
lift-fma.f64N/A
associate-+r+N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
+-commutativeN/A
Applied rewrites98.4%
if -2.00000000000000003e306 < (*.f64 (*.f64 (+.f64 a (*.f64 b c)) c) i) Initial program 95.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
lower-fma.f64N/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6496.8
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6497.8
Applied rewrites97.8%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
lift-*.f64N/A
associate-*r*N/A
lift-fma.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
distribute-rgt-neg-inN/A
lift-*.f64N/A
associate-+l+N/A
lower-fma.f64N/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
Applied rewrites97.8%
Final simplification98.0%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (fma z t (fma c (- (* i (fma b c a))) (* x y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * fma(z, t, fma(c, -(i * fma(b, c, a)), (x * y)));
}
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * fma(z, t, fma(c, Float64(-Float64(i * fma(b, c, a))), Float64(x * y)))) end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(z * t + N[(c * (-N[(i * N[(b * c + a), $MachinePrecision]), $MachinePrecision]) + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \mathsf{fma}\left(z, t, \mathsf{fma}\left(c, -i \cdot \mathsf{fma}\left(b, c, a\right), x \cdot y\right)\right)
\end{array}
Initial program 90.9%
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
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites93.9%
Final simplification93.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* 2.0 (* x y))))
(if (<= (* x y) -2.6e+106)
t_1
(if (<= (* x y) 2.1e+111) (* 2.0 (* z t)) 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 * (x * y);
double tmp;
if ((x * y) <= -2.6e+106) {
tmp = t_1;
} else if ((x * y) <= 2.1e+111) {
tmp = 2.0 * (z * t);
} 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 * (x * y)
if ((x * y) <= (-2.6d+106)) then
tmp = t_1
else if ((x * y) <= 2.1d+111) then
tmp = 2.0d0 * (z * t)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = 2.0 * (x * y);
double tmp;
if ((x * y) <= -2.6e+106) {
tmp = t_1;
} else if ((x * y) <= 2.1e+111) {
tmp = 2.0 * (z * t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = 2.0 * (x * y) tmp = 0 if (x * y) <= -2.6e+106: tmp = t_1 elif (x * y) <= 2.1e+111: tmp = 2.0 * (z * t) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(2.0 * Float64(x * y)) tmp = 0.0 if (Float64(x * y) <= -2.6e+106) tmp = t_1; elseif (Float64(x * y) <= 2.1e+111) tmp = Float64(2.0 * Float64(z * t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = 2.0 * (x * y); tmp = 0.0; if ((x * y) <= -2.6e+106) tmp = t_1; elseif ((x * y) <= 2.1e+111) tmp = 2.0 * (z * t); 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[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -2.6e+106], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 2.1e+111], N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 \cdot \left(x \cdot y\right)\\
\mathbf{if}\;x \cdot y \leq -2.6 \cdot 10^{+106}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq 2.1 \cdot 10^{+111}:\\
\;\;\;\;2 \cdot \left(z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -2.6000000000000002e106 or 2.09999999999999995e111 < (*.f64 x y) Initial program 86.9%
Taylor expanded in x around inf
lower-*.f6465.7
Applied rewrites65.7%
if -2.6000000000000002e106 < (*.f64 x y) < 2.09999999999999995e111Initial program 92.5%
Taylor expanded in z around inf
lower-*.f6434.4
Applied rewrites34.4%
Final simplification43.6%
(FPCore (x y z t a b c i) :precision binary64 (* 2.0 (* z t)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return 2.0 * (z * t);
}
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 * (z * t)
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 * (z * t);
}
def code(x, y, z, t, a, b, c, i): return 2.0 * (z * t)
function code(x, y, z, t, a, b, c, i) return Float64(2.0 * Float64(z * t)) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = 2.0 * (z * t); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(2.0 * N[(z * t), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
2 \cdot \left(z \cdot t\right)
\end{array}
Initial program 90.9%
Taylor expanded in z around inf
lower-*.f6429.1
Applied rewrites29.1%
Final simplification29.1%
(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 2024220
(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))))