
(FPCore (x y z) :precision binary64 (+ (* x (cos y)) (* z (sin y))))
double code(double x, double y, double z) {
return (x * cos(y)) + (z * sin(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 * cos(y)) + (z * sin(y))
end function
public static double code(double x, double y, double z) {
return (x * Math.cos(y)) + (z * Math.sin(y));
}
def code(x, y, z): return (x * math.cos(y)) + (z * math.sin(y))
function code(x, y, z) return Float64(Float64(x * cos(y)) + Float64(z * sin(y))) end
function tmp = code(x, y, z) tmp = (x * cos(y)) + (z * sin(y)); end
code[x_, y_, z_] := N[(N[(x * N[Cos[y], $MachinePrecision]), $MachinePrecision] + N[(z * N[Sin[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \cos y + z \cdot \sin y
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 8 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (+ (* x (cos y)) (* z (sin y))))
double code(double x, double y, double z) {
return (x * cos(y)) + (z * sin(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 * cos(y)) + (z * sin(y))
end function
public static double code(double x, double y, double z) {
return (x * Math.cos(y)) + (z * Math.sin(y));
}
def code(x, y, z): return (x * math.cos(y)) + (z * math.sin(y))
function code(x, y, z) return Float64(Float64(x * cos(y)) + Float64(z * sin(y))) end
function tmp = code(x, y, z) tmp = (x * cos(y)) + (z * sin(y)); end
code[x_, y_, z_] := N[(N[(x * N[Cos[y], $MachinePrecision]), $MachinePrecision] + N[(z * N[Sin[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \cos y + z \cdot \sin y
\end{array}
(FPCore (x y z) :precision binary64 (fma (sin y) z (* x (cos y))))
double code(double x, double y, double z) {
return fma(sin(y), z, (x * cos(y)));
}
function code(x, y, z) return fma(sin(y), z, Float64(x * cos(y))) end
code[x_, y_, z_] := N[(N[Sin[y], $MachinePrecision] * z + N[(x * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\sin y, z, x \cdot \cos y\right)
\end{array}
Initial program 99.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.8
Applied rewrites99.8%
Final simplification99.8%
(FPCore (x y z) :precision binary64 (if (<= z -2.9e-62) (fma (sin y) z (* 1.0 x)) (if (<= z 1.2e-20) (* (cos y) x) (+ (* z (sin y)) (* 1.0 x)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -2.9e-62) {
tmp = fma(sin(y), z, (1.0 * x));
} else if (z <= 1.2e-20) {
tmp = cos(y) * x;
} else {
tmp = (z * sin(y)) + (1.0 * x);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -2.9e-62) tmp = fma(sin(y), z, Float64(1.0 * x)); elseif (z <= 1.2e-20) tmp = Float64(cos(y) * x); else tmp = Float64(Float64(z * sin(y)) + Float64(1.0 * x)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -2.9e-62], N[(N[Sin[y], $MachinePrecision] * z + N[(1.0 * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.2e-20], N[(N[Cos[y], $MachinePrecision] * x), $MachinePrecision], N[(N[(z * N[Sin[y], $MachinePrecision]), $MachinePrecision] + N[(1.0 * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.9 \cdot 10^{-62}:\\
\;\;\;\;\mathsf{fma}\left(\sin y, z, 1 \cdot x\right)\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{-20}:\\
\;\;\;\;\cos y \cdot x\\
\mathbf{else}:\\
\;\;\;\;z \cdot \sin y + 1 \cdot x\\
\end{array}
\end{array}
if z < -2.89999999999999986e-62Initial program 99.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.8
Applied rewrites99.8%
Taylor expanded in y around 0
Applied rewrites94.1%
if -2.89999999999999986e-62 < z < 1.19999999999999996e-20Initial program 99.8%
lift-+.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-+.f64N/A
inv-powN/A
lower-pow.f6499.7
Applied rewrites99.7%
lift-pow.f64N/A
unpow-1N/A
lower-/.f6499.7
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6499.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.7
Applied rewrites99.7%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f6499.8
Applied rewrites99.8%
Taylor expanded in x around inf
Applied rewrites91.4%
if 1.19999999999999996e-20 < z Initial program 99.9%
Taylor expanded in y around 0
Applied rewrites93.6%
Final simplification92.9%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* z (sin y))))
(if (<= y -1.05e+259)
(* (cos y) x)
(if (<= y -0.001)
t_0
(if (<= y 0.012) (fma (fma (* x y) -0.5 z) y x) t_0)))))
double code(double x, double y, double z) {
double t_0 = z * sin(y);
double tmp;
if (y <= -1.05e+259) {
tmp = cos(y) * x;
} else if (y <= -0.001) {
tmp = t_0;
} else if (y <= 0.012) {
tmp = fma(fma((x * y), -0.5, z), y, x);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(z * sin(y)) tmp = 0.0 if (y <= -1.05e+259) tmp = Float64(cos(y) * x); elseif (y <= -0.001) tmp = t_0; elseif (y <= 0.012) tmp = fma(fma(Float64(x * y), -0.5, z), y, x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[Sin[y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.05e+259], N[(N[Cos[y], $MachinePrecision] * x), $MachinePrecision], If[LessEqual[y, -0.001], t$95$0, If[LessEqual[y, 0.012], N[(N[(N[(x * y), $MachinePrecision] * -0.5 + z), $MachinePrecision] * y + x), $MachinePrecision], t$95$0]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \sin y\\
\mathbf{if}\;y \leq -1.05 \cdot 10^{+259}:\\
\;\;\;\;\cos y \cdot x\\
\mathbf{elif}\;y \leq -0.001:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 0.012:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(x \cdot y, -0.5, z\right), y, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1.05000000000000003e259Initial program 99.3%
lift-+.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-+.f64N/A
inv-powN/A
lower-pow.f6499.6
Applied rewrites99.6%
lift-pow.f64N/A
unpow-1N/A
lower-/.f6499.6
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6499.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.6
Applied rewrites99.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f6486.2
Applied rewrites86.2%
Taylor expanded in x around inf
Applied rewrites82.1%
if -1.05000000000000003e259 < y < -1e-3 or 0.012 < y Initial program 99.7%
Taylor expanded in x around 0
*-commutativeN/A
lower-*.f64N/A
lower-sin.f6460.4
Applied rewrites60.4%
if -1e-3 < y < 0.012Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6499.9
Applied rewrites99.9%
Final simplification83.2%
(FPCore (x y z) :precision binary64 (let* ((t_0 (fma (sin y) z (* 1.0 x)))) (if (<= z -2.9e-62) t_0 (if (<= z 1.2e-20) (* (cos y) x) t_0))))
double code(double x, double y, double z) {
double t_0 = fma(sin(y), z, (1.0 * x));
double tmp;
if (z <= -2.9e-62) {
tmp = t_0;
} else if (z <= 1.2e-20) {
tmp = cos(y) * x;
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = fma(sin(y), z, Float64(1.0 * x)) tmp = 0.0 if (z <= -2.9e-62) tmp = t_0; elseif (z <= 1.2e-20) tmp = Float64(cos(y) * x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[Sin[y], $MachinePrecision] * z + N[(1.0 * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.9e-62], t$95$0, If[LessEqual[z, 1.2e-20], N[(N[Cos[y], $MachinePrecision] * x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(\sin y, z, 1 \cdot x\right)\\
\mathbf{if}\;z \leq -2.9 \cdot 10^{-62}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{-20}:\\
\;\;\;\;\cos y \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -2.89999999999999986e-62 or 1.19999999999999996e-20 < z Initial program 99.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.9
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.9
Applied rewrites99.9%
Taylor expanded in y around 0
Applied rewrites93.9%
if -2.89999999999999986e-62 < z < 1.19999999999999996e-20Initial program 99.8%
lift-+.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-+.f64N/A
inv-powN/A
lower-pow.f6499.7
Applied rewrites99.7%
lift-pow.f64N/A
unpow-1N/A
lower-/.f6499.7
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6499.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.7
Applied rewrites99.7%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f6499.8
Applied rewrites99.8%
Taylor expanded in x around inf
Applied rewrites91.4%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* z (sin y))))
(if (<= y -0.001)
t_0
(if (<= y 0.012) (fma (fma (* x y) -0.5 z) y x) t_0))))
double code(double x, double y, double z) {
double t_0 = z * sin(y);
double tmp;
if (y <= -0.001) {
tmp = t_0;
} else if (y <= 0.012) {
tmp = fma(fma((x * y), -0.5, z), y, x);
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(z * sin(y)) tmp = 0.0 if (y <= -0.001) tmp = t_0; elseif (y <= 0.012) tmp = fma(fma(Float64(x * y), -0.5, z), y, x); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[Sin[y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -0.001], t$95$0, If[LessEqual[y, 0.012], N[(N[(N[(x * y), $MachinePrecision] * -0.5 + z), $MachinePrecision] * y + x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := z \cdot \sin y\\
\mathbf{if}\;y \leq -0.001:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 0.012:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(x \cdot y, -0.5, z\right), y, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1e-3 or 0.012 < y Initial program 99.7%
Taylor expanded in x around 0
*-commutativeN/A
lower-*.f64N/A
lower-sin.f6457.6
Applied rewrites57.6%
if -1e-3 < y < 0.012Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6499.9
Applied rewrites99.9%
Final simplification81.4%
(FPCore (x y z) :precision binary64 (if (<= z -2.2e+18) (* z y) (if (<= z 2.4e+151) (* 1.0 x) (* z y))))
double code(double x, double y, double z) {
double tmp;
if (z <= -2.2e+18) {
tmp = z * y;
} else if (z <= 2.4e+151) {
tmp = 1.0 * x;
} else {
tmp = z * 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 (z <= (-2.2d+18)) then
tmp = z * y
else if (z <= 2.4d+151) then
tmp = 1.0d0 * x
else
tmp = z * y
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (z <= -2.2e+18) {
tmp = z * y;
} else if (z <= 2.4e+151) {
tmp = 1.0 * x;
} else {
tmp = z * y;
}
return tmp;
}
def code(x, y, z): tmp = 0 if z <= -2.2e+18: tmp = z * y elif z <= 2.4e+151: tmp = 1.0 * x else: tmp = z * y return tmp
function code(x, y, z) tmp = 0.0 if (z <= -2.2e+18) tmp = Float64(z * y); elseif (z <= 2.4e+151) tmp = Float64(1.0 * x); else tmp = Float64(z * y); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (z <= -2.2e+18) tmp = z * y; elseif (z <= 2.4e+151) tmp = 1.0 * x; else tmp = z * y; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[z, -2.2e+18], N[(z * y), $MachinePrecision], If[LessEqual[z, 2.4e+151], N[(1.0 * x), $MachinePrecision], N[(z * y), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.2 \cdot 10^{+18}:\\
\;\;\;\;z \cdot y\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{+151}:\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;z \cdot y\\
\end{array}
\end{array}
if z < -2.2e18 or 2.4000000000000001e151 < z Initial program 99.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6456.3
Applied rewrites56.3%
Taylor expanded in x around 0
Applied rewrites39.9%
if -2.2e18 < z < 2.4000000000000001e151Initial program 99.9%
lift-+.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-+.f64N/A
inv-powN/A
lower-pow.f6499.7
Applied rewrites99.7%
lift-pow.f64N/A
unpow-1N/A
lower-/.f6499.7
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6499.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6499.7
Applied rewrites99.7%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f6497.4
Applied rewrites97.4%
Taylor expanded in y around 0
Applied rewrites54.4%
(FPCore (x y z) :precision binary64 (fma z y x))
double code(double x, double y, double z) {
return fma(z, y, x);
}
function code(x, y, z) return fma(z, y, x) end
code[x_, y_, z_] := N[(z * y + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(z, y, x\right)
\end{array}
Initial program 99.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6458.8
Applied rewrites58.8%
(FPCore (x y z) :precision binary64 (* z y))
double code(double x, double y, double z) {
return z * y;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = z * y
end function
public static double code(double x, double y, double z) {
return z * y;
}
def code(x, y, z): return z * y
function code(x, y, z) return Float64(z * y) end
function tmp = code(x, y, z) tmp = z * y; end
code[x_, y_, z_] := N[(z * y), $MachinePrecision]
\begin{array}{l}
\\
z \cdot y
\end{array}
Initial program 99.8%
Taylor expanded in y around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f6458.8
Applied rewrites58.8%
Taylor expanded in x around 0
Applied rewrites22.0%
herbie shell --seed 2024308
(FPCore (x y z)
:name "Diagrams.ThreeD.Transform:aboutY from diagrams-lib-1.3.0.3"
:precision binary64
(+ (* x (cos y)) (* z (sin y))))