
(FPCore (x y z) :precision binary64 (+ x (* (* (- y x) 6.0) z)))
double code(double x, double y, double z) {
return x + (((y - x) * 6.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) * z)
end function
public static double code(double x, double y, double z) {
return x + (((y - x) * 6.0) * z);
}
def code(x, y, z): return x + (((y - x) * 6.0) * z)
function code(x, y, z) return Float64(x + Float64(Float64(Float64(y - x) * 6.0) * z)) end
function tmp = code(x, y, z) tmp = x + (((y - x) * 6.0) * z); end
code[x_, y_, z_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * 6.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\left(y - x\right) \cdot 6\right) \cdot z
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (+ x (* (* (- y x) 6.0) z)))
double code(double x, double y, double z) {
return x + (((y - x) * 6.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) * z)
end function
public static double code(double x, double y, double z) {
return x + (((y - x) * 6.0) * z);
}
def code(x, y, z): return x + (((y - x) * 6.0) * z)
function code(x, y, z) return Float64(x + Float64(Float64(Float64(y - x) * 6.0) * z)) end
function tmp = code(x, y, z) tmp = x + (((y - x) * 6.0) * z); end
code[x_, y_, z_] := N[(x + N[(N[(N[(y - x), $MachinePrecision] * 6.0), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\left(y - x\right) \cdot 6\right) \cdot z
\end{array}
(FPCore (x y z) :precision binary64 (fma (* (- y x) 6.0) z x))
double code(double x, double y, double z) {
return fma(((y - x) * 6.0), z, x);
}
function code(x, y, z) return fma(Float64(Float64(y - x) * 6.0), z, x) end
code[x_, y_, z_] := N[(N[(N[(y - x), $MachinePrecision] * 6.0), $MachinePrecision] * z + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\left(y - x\right) \cdot 6, z, x\right)
\end{array}
Initial program 99.8%
lift--.f64N/A
lift-*.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6499.8
Applied rewrites99.8%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* (* z -6.0) (- x y)))) (if (<= z -0.165) t_0 (if (<= z 0.165) (fma (* y z) 6.0 x) t_0))))
double code(double x, double y, double z) {
double t_0 = (z * -6.0) * (x - y);
double tmp;
if (z <= -0.165) {
tmp = t_0;
} else if (z <= 0.165) {
tmp = fma((y * z), 6.0, x);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(z * -6.0) * Float64(x - y)) tmp = 0.0 if (z <= -0.165) tmp = t_0; elseif (z <= 0.165) tmp = fma(Float64(y * z), 6.0, x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(z * -6.0), $MachinePrecision] * N[(x - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.165], t$95$0, If[LessEqual[z, 0.165], N[(N[(y * z), $MachinePrecision] * 6.0 + x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(z \cdot -6\right) \cdot \left(x - y\right)\\
\mathbf{if}\;z \leq -0.165:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 0.165:\\
\;\;\;\;\mathsf{fma}\left(y \cdot z, 6, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -0.165000000000000008 or 0.165000000000000008 < z Initial program 99.8%
Taylor expanded in z around inf
associate-*r*N/A
distribute-lft-out--N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-out--N/A
distribute-lft-out--N/A
neg-mul-1N/A
neg-sub0N/A
associate-+l-N/A
neg-sub0N/A
mul-1-negN/A
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
associate-*r/N/A
*-rgt-identityN/A
Applied rewrites98.7%
if -0.165000000000000008 < z < 0.165000000000000008Initial program 99.9%
lift--.f64N/A
lift-*.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6499.9
Applied rewrites99.9%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f6498.4
Applied rewrites98.4%
Final simplification98.6%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* z (* -6.0 (- x y))))) (if (<= z -0.15) t_0 (if (<= z 0.165) (fma (* y z) 6.0 x) t_0))))
double code(double x, double y, double z) {
double t_0 = z * (-6.0 * (x - y));
double tmp;
if (z <= -0.15) {
tmp = t_0;
} else if (z <= 0.165) {
tmp = fma((y * z), 6.0, x);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(z * Float64(-6.0 * Float64(x - y))) tmp = 0.0 if (z <= -0.15) tmp = t_0; elseif (z <= 0.165) tmp = fma(Float64(y * z), 6.0, x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[(-6.0 * N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -0.15], t$95$0, If[LessEqual[z, 0.165], N[(N[(y * z), $MachinePrecision] * 6.0 + x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \left(-6 \cdot \left(x - y\right)\right)\\
\mathbf{if}\;z \leq -0.15:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 0.165:\\
\;\;\;\;\mathsf{fma}\left(y \cdot z, 6, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -0.149999999999999994 or 0.165000000000000008 < z Initial program 99.8%
Taylor expanded in z around inf
associate-*r*N/A
distribute-lft-out--N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-out--N/A
distribute-lft-out--N/A
neg-mul-1N/A
neg-sub0N/A
associate-+l-N/A
neg-sub0N/A
mul-1-negN/A
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
associate-*r/N/A
*-rgt-identityN/A
Applied rewrites98.7%
lift--.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6498.7
Applied rewrites98.7%
if -0.149999999999999994 < z < 0.165000000000000008Initial program 99.9%
lift--.f64N/A
lift-*.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6499.9
Applied rewrites99.9%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f6498.4
Applied rewrites98.4%
Final simplification98.5%
(FPCore (x y z) :precision binary64 (let* ((t_0 (fma (* y z) 6.0 x))) (if (<= y -2.7e-48) t_0 (if (<= y 5.2e-58) (fma z (* x -6.0) x) t_0))))
double code(double x, double y, double z) {
double t_0 = fma((y * z), 6.0, x);
double tmp;
if (y <= -2.7e-48) {
tmp = t_0;
} else if (y <= 5.2e-58) {
tmp = fma(z, (x * -6.0), x);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = fma(Float64(y * z), 6.0, x) tmp = 0.0 if (y <= -2.7e-48) tmp = t_0; elseif (y <= 5.2e-58) tmp = fma(z, Float64(x * -6.0), x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(y * z), $MachinePrecision] * 6.0 + x), $MachinePrecision]}, If[LessEqual[y, -2.7e-48], t$95$0, If[LessEqual[y, 5.2e-58], N[(z * N[(x * -6.0), $MachinePrecision] + x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(y \cdot z, 6, x\right)\\
\mathbf{if}\;y \leq -2.7 \cdot 10^{-48}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 5.2 \cdot 10^{-58}:\\
\;\;\;\;\mathsf{fma}\left(z, x \cdot -6, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -2.70000000000000011e-48 or 5.20000000000000013e-58 < y Initial program 99.8%
lift--.f64N/A
lift-*.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6499.8
Applied rewrites99.8%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f6487.4
Applied rewrites87.4%
if -2.70000000000000011e-48 < y < 5.20000000000000013e-58Initial program 99.8%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*l*N/A
*-lft-identityN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6491.5
Applied rewrites91.5%
Final simplification89.1%
(FPCore (x y z) :precision binary64 (if (<= y -3.8e+57) (* y (* 6.0 z)) (if (<= y 1.8e+66) (fma z (* x -6.0) x) (* 6.0 (* y z)))))
double code(double x, double y, double z) {
double tmp;
if (y <= -3.8e+57) {
tmp = y * (6.0 * z);
} else if (y <= 1.8e+66) {
tmp = fma(z, (x * -6.0), x);
} else {
tmp = 6.0 * (y * z);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= -3.8e+57) tmp = Float64(y * Float64(6.0 * z)); elseif (y <= 1.8e+66) tmp = fma(z, Float64(x * -6.0), x); else tmp = Float64(6.0 * Float64(y * z)); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, -3.8e+57], N[(y * N[(6.0 * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.8e+66], N[(z * N[(x * -6.0), $MachinePrecision] + x), $MachinePrecision], N[(6.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.8 \cdot 10^{+57}:\\
\;\;\;\;y \cdot \left(6 \cdot z\right)\\
\mathbf{elif}\;y \leq 1.8 \cdot 10^{+66}:\\
\;\;\;\;\mathsf{fma}\left(z, x \cdot -6, x\right)\\
\mathbf{else}:\\
\;\;\;\;6 \cdot \left(y \cdot z\right)\\
\end{array}
\end{array}
if y < -3.7999999999999999e57Initial program 99.7%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6483.3
Applied rewrites83.3%
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6483.4
Applied rewrites83.4%
if -3.7999999999999999e57 < y < 1.8e66Initial program 99.8%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
*-commutativeN/A
associate-*l*N/A
*-lft-identityN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6483.9
Applied rewrites83.9%
if 1.8e66 < y Initial program 99.8%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6473.9
Applied rewrites73.9%
Final simplification81.9%
(FPCore (x y z) :precision binary64 (if (<= y -2.7e-48) (* z (* y 6.0)) (if (<= y 4.5e-53) (* x (* z -6.0)) (* 6.0 (* y z)))))
double code(double x, double y, double z) {
double tmp;
if (y <= -2.7e-48) {
tmp = z * (y * 6.0);
} else if (y <= 4.5e-53) {
tmp = x * (z * -6.0);
} else {
tmp = 6.0 * (y * z);
}
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 <= (-2.7d-48)) then
tmp = z * (y * 6.0d0)
else if (y <= 4.5d-53) then
tmp = x * (z * (-6.0d0))
else
tmp = 6.0d0 * (y * z)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= -2.7e-48) {
tmp = z * (y * 6.0);
} else if (y <= 4.5e-53) {
tmp = x * (z * -6.0);
} else {
tmp = 6.0 * (y * z);
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= -2.7e-48: tmp = z * (y * 6.0) elif y <= 4.5e-53: tmp = x * (z * -6.0) else: tmp = 6.0 * (y * z) return tmp
function code(x, y, z) tmp = 0.0 if (y <= -2.7e-48) tmp = Float64(z * Float64(y * 6.0)); elseif (y <= 4.5e-53) tmp = Float64(x * Float64(z * -6.0)); else tmp = Float64(6.0 * Float64(y * z)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= -2.7e-48) tmp = z * (y * 6.0); elseif (y <= 4.5e-53) tmp = x * (z * -6.0); else tmp = 6.0 * (y * z); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, -2.7e-48], N[(z * N[(y * 6.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.5e-53], N[(x * N[(z * -6.0), $MachinePrecision]), $MachinePrecision], N[(6.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.7 \cdot 10^{-48}:\\
\;\;\;\;z \cdot \left(y \cdot 6\right)\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-53}:\\
\;\;\;\;x \cdot \left(z \cdot -6\right)\\
\mathbf{else}:\\
\;\;\;\;6 \cdot \left(y \cdot z\right)\\
\end{array}
\end{array}
if y < -2.70000000000000011e-48Initial program 99.8%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6469.5
Applied rewrites69.5%
associate-*r*N/A
*-commutativeN/A
lift-*.f64N/A
lower-*.f6469.7
Applied rewrites69.7%
if -2.70000000000000011e-48 < y < 4.49999999999999985e-53Initial program 99.8%
Taylor expanded in z around inf
associate-*r*N/A
distribute-lft-out--N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-out--N/A
distribute-lft-out--N/A
neg-mul-1N/A
neg-sub0N/A
associate-+l-N/A
neg-sub0N/A
mul-1-negN/A
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
associate-*r/N/A
*-rgt-identityN/A
Applied rewrites57.8%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied rewrites49.5%
if 4.49999999999999985e-53 < y Initial program 99.9%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6464.7
Applied rewrites64.7%
Final simplification59.6%
(FPCore (x y z) :precision binary64 (if (<= y -2.7e-48) (* y (* 6.0 z)) (if (<= y 4.5e-53) (* x (* z -6.0)) (* 6.0 (* y z)))))
double code(double x, double y, double z) {
double tmp;
if (y <= -2.7e-48) {
tmp = y * (6.0 * z);
} else if (y <= 4.5e-53) {
tmp = x * (z * -6.0);
} else {
tmp = 6.0 * (y * z);
}
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 <= (-2.7d-48)) then
tmp = y * (6.0d0 * z)
else if (y <= 4.5d-53) then
tmp = x * (z * (-6.0d0))
else
tmp = 6.0d0 * (y * z)
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= -2.7e-48) {
tmp = y * (6.0 * z);
} else if (y <= 4.5e-53) {
tmp = x * (z * -6.0);
} else {
tmp = 6.0 * (y * z);
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= -2.7e-48: tmp = y * (6.0 * z) elif y <= 4.5e-53: tmp = x * (z * -6.0) else: tmp = 6.0 * (y * z) return tmp
function code(x, y, z) tmp = 0.0 if (y <= -2.7e-48) tmp = Float64(y * Float64(6.0 * z)); elseif (y <= 4.5e-53) tmp = Float64(x * Float64(z * -6.0)); else tmp = Float64(6.0 * Float64(y * z)); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= -2.7e-48) tmp = y * (6.0 * z); elseif (y <= 4.5e-53) tmp = x * (z * -6.0); else tmp = 6.0 * (y * z); end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, -2.7e-48], N[(y * N[(6.0 * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.5e-53], N[(x * N[(z * -6.0), $MachinePrecision]), $MachinePrecision], N[(6.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.7 \cdot 10^{-48}:\\
\;\;\;\;y \cdot \left(6 \cdot z\right)\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-53}:\\
\;\;\;\;x \cdot \left(z \cdot -6\right)\\
\mathbf{else}:\\
\;\;\;\;6 \cdot \left(y \cdot z\right)\\
\end{array}
\end{array}
if y < -2.70000000000000011e-48Initial program 99.8%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6469.5
Applied rewrites69.5%
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6469.6
Applied rewrites69.6%
if -2.70000000000000011e-48 < y < 4.49999999999999985e-53Initial program 99.8%
Taylor expanded in z around inf
associate-*r*N/A
distribute-lft-out--N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-out--N/A
distribute-lft-out--N/A
neg-mul-1N/A
neg-sub0N/A
associate-+l-N/A
neg-sub0N/A
mul-1-negN/A
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
associate-*r/N/A
*-rgt-identityN/A
Applied rewrites57.8%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied rewrites49.5%
if 4.49999999999999985e-53 < y Initial program 99.9%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6464.7
Applied rewrites64.7%
Final simplification59.6%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* 6.0 (* y z)))) (if (<= y -2.7e-48) t_0 (if (<= y 4.5e-53) (* x (* z -6.0)) t_0))))
double code(double x, double y, double z) {
double t_0 = 6.0 * (y * z);
double tmp;
if (y <= -2.7e-48) {
tmp = t_0;
} else if (y <= 4.5e-53) {
tmp = x * (z * -6.0);
} else {
tmp = t_0;
}
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) :: t_0
real(8) :: tmp
t_0 = 6.0d0 * (y * z)
if (y <= (-2.7d-48)) then
tmp = t_0
else if (y <= 4.5d-53) then
tmp = x * (z * (-6.0d0))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = 6.0 * (y * z);
double tmp;
if (y <= -2.7e-48) {
tmp = t_0;
} else if (y <= 4.5e-53) {
tmp = x * (z * -6.0);
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = 6.0 * (y * z) tmp = 0 if y <= -2.7e-48: tmp = t_0 elif y <= 4.5e-53: tmp = x * (z * -6.0) else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(6.0 * Float64(y * z)) tmp = 0.0 if (y <= -2.7e-48) tmp = t_0; elseif (y <= 4.5e-53) tmp = Float64(x * Float64(z * -6.0)); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = 6.0 * (y * z); tmp = 0.0; if (y <= -2.7e-48) tmp = t_0; elseif (y <= 4.5e-53) tmp = x * (z * -6.0); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(6.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.7e-48], t$95$0, If[LessEqual[y, 4.5e-53], N[(x * N[(z * -6.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 6 \cdot \left(y \cdot z\right)\\
\mathbf{if}\;y \leq -2.7 \cdot 10^{-48}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-53}:\\
\;\;\;\;x \cdot \left(z \cdot -6\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -2.70000000000000011e-48 or 4.49999999999999985e-53 < y Initial program 99.8%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6467.3
Applied rewrites67.3%
if -2.70000000000000011e-48 < y < 4.49999999999999985e-53Initial program 99.8%
Taylor expanded in z around inf
associate-*r*N/A
distribute-lft-out--N/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
distribute-lft-neg-inN/A
mul-1-negN/A
distribute-rgt-out--N/A
distribute-lft-out--N/A
neg-mul-1N/A
neg-sub0N/A
associate-+l-N/A
neg-sub0N/A
mul-1-negN/A
*-lft-identityN/A
*-inversesN/A
associate-*l/N/A
associate-*r/N/A
associate-*r/N/A
*-rgt-identityN/A
Applied rewrites57.8%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6449.5
Applied rewrites49.5%
Final simplification59.6%
(FPCore (x y z) :precision binary64 (* 6.0 (* y z)))
double code(double x, double y, double z) {
return 6.0 * (y * z);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 6.0d0 * (y * z)
end function
public static double code(double x, double y, double z) {
return 6.0 * (y * z);
}
def code(x, y, z): return 6.0 * (y * z)
function code(x, y, z) return Float64(6.0 * Float64(y * z)) end
function tmp = code(x, y, z) tmp = 6.0 * (y * z); end
code[x_, y_, z_] := N[(6.0 * N[(y * z), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
6 \cdot \left(y \cdot z\right)
\end{array}
Initial program 99.8%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6442.6
Applied rewrites42.6%
(FPCore (x y z) :precision binary64 (- x (* (* 6.0 z) (- x y))))
double code(double x, double y, double z) {
return x - ((6.0 * z) * (x - y));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x - ((6.0d0 * z) * (x - y))
end function
public static double code(double x, double y, double z) {
return x - ((6.0 * z) * (x - y));
}
def code(x, y, z): return x - ((6.0 * z) * (x - y))
function code(x, y, z) return Float64(x - Float64(Float64(6.0 * z) * Float64(x - y))) end
function tmp = code(x, y, z) tmp = x - ((6.0 * z) * (x - y)); end
code[x_, y_, z_] := N[(x - N[(N[(6.0 * z), $MachinePrecision] * N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \left(6 \cdot z\right) \cdot \left(x - y\right)
\end{array}
herbie shell --seed 2024214
(FPCore (x y z)
:name "Data.Colour.RGBSpace.HSL:hsl from colour-2.3.3, E"
:precision binary64
:alt
(! :herbie-platform default (- x (* (* 6 z) (- x y))))
(+ x (* (* (- y x) 6.0) z)))