
(FPCore (x y z) :precision binary64 (+ x (* (* (- y x) 6.0) (- (/ 2.0 3.0) z))))
double code(double x, double y, double z) {
return x + (((y - x) * 6.0) * ((2.0 / 3.0) - z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x + (((y - x) * 6.0d0) * ((2.0d0 / 3.0d0) - z))
end function
public static double code(double x, double y, double z) {
return x + (((y - x) * 6.0) * ((2.0 / 3.0) - z));
}
def code(x, y, z): return x + (((y - x) * 6.0) * ((2.0 / 3.0) - z))
function code(x, y, z) return Float64(x + Float64(Float64(Float64(y - x) * 6.0) * Float64(Float64(2.0 / 3.0) - z))) end
function tmp = code(x, y, z) tmp = x + (((y - x) * 6.0) * ((2.0 / 3.0) - z)); end
code[x_, y_, z_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * 6.0), $MachinePrecision] * N[(N[(2.0 / 3.0), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\left(y - x\right) \cdot 6\right) \cdot \left(\frac{2}{3} - z\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (+ x (* (* (- y x) 6.0) (- (/ 2.0 3.0) z))))
double code(double x, double y, double z) {
return x + (((y - x) * 6.0) * ((2.0 / 3.0) - z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x + (((y - x) * 6.0d0) * ((2.0d0 / 3.0d0) - z))
end function
public static double code(double x, double y, double z) {
return x + (((y - x) * 6.0) * ((2.0 / 3.0) - z));
}
def code(x, y, z): return x + (((y - x) * 6.0) * ((2.0 / 3.0) - z))
function code(x, y, z) return Float64(x + Float64(Float64(Float64(y - x) * 6.0) * Float64(Float64(2.0 / 3.0) - z))) end
function tmp = code(x, y, z) tmp = x + (((y - x) * 6.0) * ((2.0 / 3.0) - z)); end
code[x_, y_, z_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * 6.0), $MachinePrecision] * N[(N[(2.0 / 3.0), $MachinePrecision] - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\left(y - x\right) \cdot 6\right) \cdot \left(\frac{2}{3} - z\right)
\end{array}
(FPCore (x y z) :precision binary64 (+ (fma (* (- x y) z) 6.0 (* 4.0 (- y x))) x))
double code(double x, double y, double z) {
return fma(((x - y) * z), 6.0, (4.0 * (y - x))) + x;
}
function code(x, y, z) return Float64(fma(Float64(Float64(x - y) * z), 6.0, Float64(4.0 * Float64(y - x))) + x) end
code[x_, y_, z_] := N[(N[(N[(N[(x - y), $MachinePrecision] * z), $MachinePrecision] * 6.0 + N[(4.0 * N[(y - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\left(x - y\right) \cdot z, 6, 4 \cdot \left(y - x\right)\right) + x
\end{array}
Initial program 99.3%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-rgt-inN/A
+-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lift-/.f64N/A
lower-*.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-eval99.8
Applied rewrites99.8%
Final simplification99.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (/ 2.0 3.0) z)) (t_1 (* (fma 6.0 z -3.0) x)))
(if (<= t_0 -5.0)
t_1
(if (<= t_0 0.6666666667)
(fma -3.0 x (* 4.0 y))
(if (<= t_0 20000000000000.0) t_1 (* (* -6.0 z) y))))))
double code(double x, double y, double z) {
double t_0 = (2.0 / 3.0) - z;
double t_1 = fma(6.0, z, -3.0) * x;
double tmp;
if (t_0 <= -5.0) {
tmp = t_1;
} else if (t_0 <= 0.6666666667) {
tmp = fma(-3.0, x, (4.0 * y));
} else if (t_0 <= 20000000000000.0) {
tmp = t_1;
} else {
tmp = (-6.0 * z) * y;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(2.0 / 3.0) - z) t_1 = Float64(fma(6.0, z, -3.0) * x) tmp = 0.0 if (t_0 <= -5.0) tmp = t_1; elseif (t_0 <= 0.6666666667) tmp = fma(-3.0, x, Float64(4.0 * y)); elseif (t_0 <= 20000000000000.0) tmp = t_1; else tmp = Float64(Float64(-6.0 * z) * y); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(2.0 / 3.0), $MachinePrecision] - z), $MachinePrecision]}, Block[{t$95$1 = N[(N[(6.0 * z + -3.0), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[t$95$0, -5.0], t$95$1, If[LessEqual[t$95$0, 0.6666666667], N[(-3.0 * x + N[(4.0 * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 20000000000000.0], t$95$1, N[(N[(-6.0 * z), $MachinePrecision] * y), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{2}{3} - z\\
t_1 := \mathsf{fma}\left(6, z, -3\right) \cdot x\\
\mathbf{if}\;t\_0 \leq -5:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 0.6666666667:\\
\;\;\;\;\mathsf{fma}\left(-3, x, 4 \cdot y\right)\\
\mathbf{elif}\;t\_0 \leq 20000000000000:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(-6 \cdot z\right) \cdot y\\
\end{array}
\end{array}
if (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < -5 or 0.666666666699999966 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < 2e13Initial program 99.7%
Taylor expanded in x around inf
*-lft-identityN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
distribute-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
+-commutativeN/A
metadata-evalN/A
sub-negN/A
associate-*r*N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
Applied rewrites66.5%
if -5 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < 0.666666666699999966Initial program 98.8%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-rgt-inN/A
+-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lift-/.f64N/A
lower-*.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-eval99.9
Applied rewrites99.9%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
distribute-rgt1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-*.f6499.4
Applied rewrites99.4%
if 2e13 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) Initial program 99.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
associate-+l+N/A
lift-*.f64N/A
associate-*l*N/A
lower-fma.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites99.7%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6455.7
Applied rewrites55.7%
Taylor expanded in z around inf
Applied rewrites55.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (/ 2.0 3.0) z)) (t_1 (* (fma 6.0 z -3.0) x)))
(if (<= t_0 -5.0)
t_1
(if (<= t_0 0.6666666667)
(fma (- y x) 4.0 x)
(if (<= t_0 20000000000000.0) t_1 (* (* -6.0 z) y))))))
double code(double x, double y, double z) {
double t_0 = (2.0 / 3.0) - z;
double t_1 = fma(6.0, z, -3.0) * x;
double tmp;
if (t_0 <= -5.0) {
tmp = t_1;
} else if (t_0 <= 0.6666666667) {
tmp = fma((y - x), 4.0, x);
} else if (t_0 <= 20000000000000.0) {
tmp = t_1;
} else {
tmp = (-6.0 * z) * y;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(2.0 / 3.0) - z) t_1 = Float64(fma(6.0, z, -3.0) * x) tmp = 0.0 if (t_0 <= -5.0) tmp = t_1; elseif (t_0 <= 0.6666666667) tmp = fma(Float64(y - x), 4.0, x); elseif (t_0 <= 20000000000000.0) tmp = t_1; else tmp = Float64(Float64(-6.0 * z) * y); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(2.0 / 3.0), $MachinePrecision] - z), $MachinePrecision]}, Block[{t$95$1 = N[(N[(6.0 * z + -3.0), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[t$95$0, -5.0], t$95$1, If[LessEqual[t$95$0, 0.6666666667], N[(N[(y - x), $MachinePrecision] * 4.0 + x), $MachinePrecision], If[LessEqual[t$95$0, 20000000000000.0], t$95$1, N[(N[(-6.0 * z), $MachinePrecision] * y), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{2}{3} - z\\
t_1 := \mathsf{fma}\left(6, z, -3\right) \cdot x\\
\mathbf{if}\;t\_0 \leq -5:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 0.6666666667:\\
\;\;\;\;\mathsf{fma}\left(y - x, 4, x\right)\\
\mathbf{elif}\;t\_0 \leq 20000000000000:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(-6 \cdot z\right) \cdot y\\
\end{array}
\end{array}
if (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < -5 or 0.666666666699999966 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < 2e13Initial program 99.7%
Taylor expanded in x around inf
*-lft-identityN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
distribute-neg-inN/A
metadata-evalN/A
distribute-lft-neg-inN/A
metadata-evalN/A
+-commutativeN/A
metadata-evalN/A
sub-negN/A
associate-*r*N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
Applied rewrites66.5%
if -5 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < 0.666666666699999966Initial program 98.8%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6499.3
Applied rewrites99.3%
if 2e13 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) Initial program 99.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
associate-+l+N/A
lift-*.f64N/A
associate-*l*N/A
lower-fma.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites99.7%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6455.7
Applied rewrites55.7%
Taylor expanded in z around inf
Applied rewrites55.8%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (/ 2.0 3.0) z)))
(if (<= t_0 -5.0)
(* (* -6.0 (- y x)) z)
(if (<= t_0 1.0) (fma -3.0 x (* 4.0 y)) (* (* (- y x) z) -6.0)))))
double code(double x, double y, double z) {
double t_0 = (2.0 / 3.0) - z;
double tmp;
if (t_0 <= -5.0) {
tmp = (-6.0 * (y - x)) * z;
} else if (t_0 <= 1.0) {
tmp = fma(-3.0, x, (4.0 * y));
} else {
tmp = ((y - x) * z) * -6.0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(2.0 / 3.0) - z) tmp = 0.0 if (t_0 <= -5.0) tmp = Float64(Float64(-6.0 * Float64(y - x)) * z); elseif (t_0 <= 1.0) tmp = fma(-3.0, x, Float64(4.0 * y)); else tmp = Float64(Float64(Float64(y - x) * z) * -6.0); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(2.0 / 3.0), $MachinePrecision] - z), $MachinePrecision]}, If[LessEqual[t$95$0, -5.0], N[(N[(-6.0 * N[(y - x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$0, 1.0], N[(-3.0 * x + N[(4.0 * y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y - x), $MachinePrecision] * z), $MachinePrecision] * -6.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{2}{3} - z\\
\mathbf{if}\;t\_0 \leq -5:\\
\;\;\;\;\left(-6 \cdot \left(y - x\right)\right) \cdot z\\
\mathbf{elif}\;t\_0 \leq 1:\\
\;\;\;\;\mathsf{fma}\left(-3, x, 4 \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(y - x\right) \cdot z\right) \cdot -6\\
\end{array}
\end{array}
if (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < -5Initial program 99.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6496.7
Applied rewrites96.7%
Applied rewrites96.7%
if -5 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < 1Initial program 98.8%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-rgt-inN/A
+-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lift-/.f64N/A
lower-*.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-eval99.9
Applied rewrites99.9%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
distribute-rgt1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-*.f6498.5
Applied rewrites98.5%
if 1 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) Initial program 99.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6495.7
Applied rewrites95.7%
Final simplification97.3%
(FPCore (x y z) :precision binary64 (let* ((t_0 (- (/ 2.0 3.0) z)) (t_1 (* (* -6.0 (- y x)) z))) (if (<= t_0 -5.0) t_1 (if (<= t_0 1.0) (fma -3.0 x (* 4.0 y)) t_1))))
double code(double x, double y, double z) {
double t_0 = (2.0 / 3.0) - z;
double t_1 = (-6.0 * (y - x)) * z;
double tmp;
if (t_0 <= -5.0) {
tmp = t_1;
} else if (t_0 <= 1.0) {
tmp = fma(-3.0, x, (4.0 * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(2.0 / 3.0) - z) t_1 = Float64(Float64(-6.0 * Float64(y - x)) * z) tmp = 0.0 if (t_0 <= -5.0) tmp = t_1; elseif (t_0 <= 1.0) tmp = fma(-3.0, x, Float64(4.0 * y)); else tmp = t_1; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(2.0 / 3.0), $MachinePrecision] - z), $MachinePrecision]}, Block[{t$95$1 = N[(N[(-6.0 * N[(y - x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[t$95$0, -5.0], t$95$1, If[LessEqual[t$95$0, 1.0], N[(-3.0 * x + N[(4.0 * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{2}{3} - z\\
t_1 := \left(-6 \cdot \left(y - x\right)\right) \cdot z\\
\mathbf{if}\;t\_0 \leq -5:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 1:\\
\;\;\;\;\mathsf{fma}\left(-3, x, 4 \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < -5 or 1 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) Initial program 99.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6496.2
Applied rewrites96.2%
Applied rewrites96.2%
if -5 < (-.f64 (/.f64 #s(literal 2 binary64) #s(literal 3 binary64)) z) < 1Initial program 98.8%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-rgt-inN/A
+-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lift-/.f64N/A
lower-*.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-eval99.9
Applied rewrites99.9%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
+-commutativeN/A
distribute-lft-inN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
metadata-evalN/A
associate-+r+N/A
distribute-rgt1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-*.f6498.5
Applied rewrites98.5%
Final simplification97.3%
(FPCore (x y z) :precision binary64 (fma (- y x) 4.0 (fma (* -6.0 z) (- y x) x)))
double code(double x, double y, double z) {
return fma((y - x), 4.0, fma((-6.0 * z), (y - x), x));
}
function code(x, y, z) return fma(Float64(y - x), 4.0, fma(Float64(-6.0 * z), Float64(y - x), x)) end
code[x_, y_, z_] := N[(N[(y - x), $MachinePrecision] * 4.0 + N[(N[(-6.0 * z), $MachinePrecision] * N[(y - x), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y - x, 4, \mathsf{fma}\left(-6 \cdot z, y - x, x\right)\right)
\end{array}
Initial program 99.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
associate-+l+N/A
lift-*.f64N/A
associate-*l*N/A
lower-fma.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites99.8%
(FPCore (x y z) :precision binary64 (if (<= z -9500000.0) (* (fma -6.0 z 4.0) y) (if (<= z 0.6) (fma (- y x) 4.0 x) (* (* z x) 6.0))))
double code(double x, double y, double z) {
double tmp;
if (z <= -9500000.0) {
tmp = fma(-6.0, z, 4.0) * y;
} else if (z <= 0.6) {
tmp = fma((y - x), 4.0, x);
} else {
tmp = (z * x) * 6.0;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -9500000.0) tmp = Float64(fma(-6.0, z, 4.0) * y); elseif (z <= 0.6) tmp = fma(Float64(y - x), 4.0, x); else tmp = Float64(Float64(z * x) * 6.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -9500000.0], N[(N[(-6.0 * z + 4.0), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, 0.6], N[(N[(y - x), $MachinePrecision] * 4.0 + x), $MachinePrecision], N[(N[(z * x), $MachinePrecision] * 6.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9500000:\\
\;\;\;\;\mathsf{fma}\left(-6, z, 4\right) \cdot y\\
\mathbf{elif}\;z \leq 0.6:\\
\;\;\;\;\mathsf{fma}\left(y - x, 4, x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot x\right) \cdot 6\\
\end{array}
\end{array}
if z < -9.5e6Initial program 99.7%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-*r*N/A
metadata-evalN/A
lower-fma.f6454.7
Applied rewrites54.7%
if -9.5e6 < z < 0.599999999999999978Initial program 98.8%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6496.4
Applied rewrites96.4%
if 0.599999999999999978 < z Initial program 99.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6496.7
Applied rewrites96.7%
Taylor expanded in x around inf
Applied rewrites61.1%
Final simplification76.8%
(FPCore (x y z) :precision binary64 (if (<= z -9500000.0) (* (* -6.0 z) y) (if (<= z 0.6) (fma (- y x) 4.0 x) (* (* z x) 6.0))))
double code(double x, double y, double z) {
double tmp;
if (z <= -9500000.0) {
tmp = (-6.0 * z) * y;
} else if (z <= 0.6) {
tmp = fma((y - x), 4.0, x);
} else {
tmp = (z * x) * 6.0;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -9500000.0) tmp = Float64(Float64(-6.0 * z) * y); elseif (z <= 0.6) tmp = fma(Float64(y - x), 4.0, x); else tmp = Float64(Float64(z * x) * 6.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -9500000.0], N[(N[(-6.0 * z), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[z, 0.6], N[(N[(y - x), $MachinePrecision] * 4.0 + x), $MachinePrecision], N[(N[(z * x), $MachinePrecision] * 6.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9500000:\\
\;\;\;\;\left(-6 \cdot z\right) \cdot y\\
\mathbf{elif}\;z \leq 0.6:\\
\;\;\;\;\mathsf{fma}\left(y - x, 4, x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot x\right) \cdot 6\\
\end{array}
\end{array}
if z < -9.5e6Initial program 99.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
associate-+l+N/A
lift-*.f64N/A
associate-*l*N/A
lower-fma.f64N/A
lift-/.f64N/A
metadata-evalN/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
Applied rewrites99.7%
Taylor expanded in x around 0
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6454.7
Applied rewrites54.7%
Taylor expanded in z around inf
Applied rewrites54.1%
if -9.5e6 < z < 0.599999999999999978Initial program 98.8%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6496.4
Applied rewrites96.4%
if 0.599999999999999978 < z Initial program 99.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6496.7
Applied rewrites96.7%
Taylor expanded in x around inf
Applied rewrites61.1%
Final simplification76.6%
(FPCore (x y z) :precision binary64 (if (<= z -9500000.0) (* (* y z) -6.0) (if (<= z 0.6) (fma (- y x) 4.0 x) (* (* z x) 6.0))))
double code(double x, double y, double z) {
double tmp;
if (z <= -9500000.0) {
tmp = (y * z) * -6.0;
} else if (z <= 0.6) {
tmp = fma((y - x), 4.0, x);
} else {
tmp = (z * x) * 6.0;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -9500000.0) tmp = Float64(Float64(y * z) * -6.0); elseif (z <= 0.6) tmp = fma(Float64(y - x), 4.0, x); else tmp = Float64(Float64(z * x) * 6.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -9500000.0], N[(N[(y * z), $MachinePrecision] * -6.0), $MachinePrecision], If[LessEqual[z, 0.6], N[(N[(y - x), $MachinePrecision] * 4.0 + x), $MachinePrecision], N[(N[(z * x), $MachinePrecision] * 6.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9500000:\\
\;\;\;\;\left(y \cdot z\right) \cdot -6\\
\mathbf{elif}\;z \leq 0.6:\\
\;\;\;\;\mathsf{fma}\left(y - x, 4, x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot x\right) \cdot 6\\
\end{array}
\end{array}
if z < -9.5e6Initial program 99.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6498.5
Applied rewrites98.5%
Taylor expanded in x around 0
Applied rewrites54.0%
if -9.5e6 < z < 0.599999999999999978Initial program 98.8%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6496.4
Applied rewrites96.4%
if 0.599999999999999978 < z Initial program 99.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6496.7
Applied rewrites96.7%
Taylor expanded in x around inf
Applied rewrites61.1%
Final simplification76.6%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* (* z x) 6.0))) (if (<= z -2.9) t_0 (if (<= z 0.6) (fma (- y x) 4.0 x) t_0))))
double code(double x, double y, double z) {
double t_0 = (z * x) * 6.0;
double tmp;
if (z <= -2.9) {
tmp = t_0;
} else if (z <= 0.6) {
tmp = fma((y - x), 4.0, x);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(z * x) * 6.0) tmp = 0.0 if (z <= -2.9) tmp = t_0; elseif (z <= 0.6) tmp = fma(Float64(y - x), 4.0, x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(z * x), $MachinePrecision] * 6.0), $MachinePrecision]}, If[LessEqual[z, -2.9], t$95$0, If[LessEqual[z, 0.6], N[(N[(y - x), $MachinePrecision] * 4.0 + x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(z \cdot x\right) \cdot 6\\
\mathbf{if}\;z \leq -2.9:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 0.6:\\
\;\;\;\;\mathsf{fma}\left(y - x, 4, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -2.89999999999999991 or 0.599999999999999978 < z Initial program 99.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f6496.2
Applied rewrites96.2%
Taylor expanded in x around inf
Applied rewrites54.4%
if -2.89999999999999991 < z < 0.599999999999999978Initial program 98.8%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6498.4
Applied rewrites98.4%
Final simplification75.4%
(FPCore (x y z) :precision binary64 (if (<= y -4.4e-25) (* 4.0 y) (if (<= y 4e+25) (* -3.0 x) (* 4.0 y))))
double code(double x, double y, double z) {
double tmp;
if (y <= -4.4e-25) {
tmp = 4.0 * y;
} else if (y <= 4e+25) {
tmp = -3.0 * x;
} else {
tmp = 4.0 * y;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (y <= (-4.4d-25)) then
tmp = 4.0d0 * y
else if (y <= 4d+25) then
tmp = (-3.0d0) * x
else
tmp = 4.0d0 * y
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= -4.4e-25) {
tmp = 4.0 * y;
} else if (y <= 4e+25) {
tmp = -3.0 * x;
} else {
tmp = 4.0 * y;
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= -4.4e-25: tmp = 4.0 * y elif y <= 4e+25: tmp = -3.0 * x else: tmp = 4.0 * y return tmp
function code(x, y, z) tmp = 0.0 if (y <= -4.4e-25) tmp = Float64(4.0 * y); elseif (y <= 4e+25) tmp = Float64(-3.0 * x); else tmp = Float64(4.0 * y); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= -4.4e-25) tmp = 4.0 * y; elseif (y <= 4e+25) tmp = -3.0 * x; else tmp = 4.0 * y; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, -4.4e-25], N[(4.0 * y), $MachinePrecision], If[LessEqual[y, 4e+25], N[(-3.0 * x), $MachinePrecision], N[(4.0 * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.4 \cdot 10^{-25}:\\
\;\;\;\;4 \cdot y\\
\mathbf{elif}\;y \leq 4 \cdot 10^{+25}:\\
\;\;\;\;-3 \cdot x\\
\mathbf{else}:\\
\;\;\;\;4 \cdot y\\
\end{array}
\end{array}
if y < -4.4000000000000004e-25 or 4.00000000000000036e25 < y Initial program 99.7%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6450.5
Applied rewrites50.5%
Taylor expanded in x around 0
Applied rewrites40.6%
if -4.4000000000000004e-25 < y < 4.00000000000000036e25Initial program 98.9%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6447.0
Applied rewrites47.0%
Taylor expanded in x around inf
Applied rewrites38.2%
(FPCore (x y z) :precision binary64 (fma (fma -6.0 z 4.0) (- y x) x))
double code(double x, double y, double z) {
return fma(fma(-6.0, z, 4.0), (y - x), x);
}
function code(x, y, z) return fma(fma(-6.0, z, 4.0), Float64(y - x), x) end
code[x_, y_, z_] := N[(N[(-6.0 * z + 4.0), $MachinePrecision] * N[(y - x), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(-6, z, 4\right), y - x, x\right)
\end{array}
Initial program 99.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
distribute-lft-inN/A
neg-mul-1N/A
associate-*r*N/A
metadata-evalN/A
metadata-evalN/A
lower-fma.f64N/A
metadata-evalN/A
lift-/.f64N/A
metadata-evalN/A
metadata-eval99.8
Applied rewrites99.8%
(FPCore (x y z) :precision binary64 (fma (- y x) 4.0 x))
double code(double x, double y, double z) {
return fma((y - x), 4.0, x);
}
function code(x, y, z) return fma(Float64(y - x), 4.0, x) end
code[x_, y_, z_] := N[(N[(y - x), $MachinePrecision] * 4.0 + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(y - x, 4, x\right)
\end{array}
Initial program 99.3%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6448.7
Applied rewrites48.7%
(FPCore (x y z) :precision binary64 (* -3.0 x))
double code(double x, double y, double z) {
return -3.0 * x;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (-3.0d0) * x
end function
public static double code(double x, double y, double z) {
return -3.0 * x;
}
def code(x, y, z): return -3.0 * x
function code(x, y, z) return Float64(-3.0 * x) end
function tmp = code(x, y, z) tmp = -3.0 * x; end
code[x_, y_, z_] := N[(-3.0 * x), $MachinePrecision]
\begin{array}{l}
\\
-3 \cdot x
\end{array}
Initial program 99.3%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f6448.7
Applied rewrites48.7%
Taylor expanded in x around inf
Applied rewrites25.3%
herbie shell --seed 2024332
(FPCore (x y z)
:name "Data.Colour.RGBSpace.HSL:hsl from colour-2.3.3, D"
:precision binary64
(+ x (* (* (- y x) 6.0) (- (/ 2.0 3.0) z))))