
(FPCore (x y z) :precision binary64 (+ (+ x (sin y)) (* z (cos y))))
double code(double x, double y, double z) {
return (x + sin(y)) + (z * cos(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 + sin(y)) + (z * cos(y))
end function
public static double code(double x, double y, double z) {
return (x + Math.sin(y)) + (z * Math.cos(y));
}
def code(x, y, z): return (x + math.sin(y)) + (z * math.cos(y))
function code(x, y, z) return Float64(Float64(x + sin(y)) + Float64(z * cos(y))) end
function tmp = code(x, y, z) tmp = (x + sin(y)) + (z * cos(y)); end
code[x_, y_, z_] := N[(N[(x + N[Sin[y], $MachinePrecision]), $MachinePrecision] + N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x + \sin y\right) + z \cdot \cos y
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (+ (+ x (sin y)) (* z (cos y))))
double code(double x, double y, double z) {
return (x + sin(y)) + (z * cos(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 + sin(y)) + (z * cos(y))
end function
public static double code(double x, double y, double z) {
return (x + Math.sin(y)) + (z * Math.cos(y));
}
def code(x, y, z): return (x + math.sin(y)) + (z * math.cos(y))
function code(x, y, z) return Float64(Float64(x + sin(y)) + Float64(z * cos(y))) end
function tmp = code(x, y, z) tmp = (x + sin(y)) + (z * cos(y)); end
code[x_, y_, z_] := N[(N[(x + N[Sin[y], $MachinePrecision]), $MachinePrecision] + N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x + \sin y\right) + z \cdot \cos y
\end{array}
(FPCore (x y z) :precision binary64 (+ (* (cos y) z) (+ (sin y) x)))
double code(double x, double y, double z) {
return (cos(y) * z) + (sin(y) + x);
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = (cos(y) * z) + (sin(y) + x)
end function
public static double code(double x, double y, double z) {
return (Math.cos(y) * z) + (Math.sin(y) + x);
}
def code(x, y, z): return (math.cos(y) * z) + (math.sin(y) + x)
function code(x, y, z) return Float64(Float64(cos(y) * z) + Float64(sin(y) + x)) end
function tmp = code(x, y, z) tmp = (cos(y) * z) + (sin(y) + x); end
code[x_, y_, z_] := N[(N[(N[Cos[y], $MachinePrecision] * z), $MachinePrecision] + N[(N[Sin[y], $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\cos y \cdot z + \left(\sin y + x\right)
\end{array}
Initial program 99.9%
Final simplification99.9%
(FPCore (x y z) :precision binary64 (if (<= z -14500000.0) (fma (cos y) z (+ y x)) (if (<= z 7.8e-19) (fma 1.0 z (+ (sin y) x)) (+ (sin y) (* (cos y) z)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -14500000.0) {
tmp = fma(cos(y), z, (y + x));
} else if (z <= 7.8e-19) {
tmp = fma(1.0, z, (sin(y) + x));
} else {
tmp = sin(y) + (cos(y) * z);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -14500000.0) tmp = fma(cos(y), z, Float64(y + x)); elseif (z <= 7.8e-19) tmp = fma(1.0, z, Float64(sin(y) + x)); else tmp = Float64(sin(y) + Float64(cos(y) * z)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -14500000.0], N[(N[Cos[y], $MachinePrecision] * z + N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.8e-19], N[(1.0 * z + N[(N[Sin[y], $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], N[(N[Sin[y], $MachinePrecision] + N[(N[Cos[y], $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -14500000:\\
\;\;\;\;\mathsf{fma}\left(\cos y, z, y + x\right)\\
\mathbf{elif}\;z \leq 7.8 \cdot 10^{-19}:\\
\;\;\;\;\mathsf{fma}\left(1, z, \sin y + x\right)\\
\mathbf{else}:\\
\;\;\;\;\sin y + \cos y \cdot z\\
\end{array}
\end{array}
if z < -1.45e7Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6485.0
Applied rewrites85.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6485.0
Applied rewrites85.0%
if -1.45e7 < z < 7.7999999999999999e-19Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites100.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
if 7.7999999999999999e-19 < z Initial program 99.8%
Taylor expanded in x around 0
lower-sin.f6493.1
Applied rewrites93.1%
Final simplification94.6%
(FPCore (x y z) :precision binary64 (if (<= z -14500000.0) (fma (cos y) z (+ y x)) (if (<= z 7.8e-19) (fma 1.0 z (+ (sin y) x)) (fma (cos y) z (sin y)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -14500000.0) {
tmp = fma(cos(y), z, (y + x));
} else if (z <= 7.8e-19) {
tmp = fma(1.0, z, (sin(y) + x));
} else {
tmp = fma(cos(y), z, sin(y));
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -14500000.0) tmp = fma(cos(y), z, Float64(y + x)); elseif (z <= 7.8e-19) tmp = fma(1.0, z, Float64(sin(y) + x)); else tmp = fma(cos(y), z, sin(y)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -14500000.0], N[(N[Cos[y], $MachinePrecision] * z + N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.8e-19], N[(1.0 * z + N[(N[Sin[y], $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], N[(N[Cos[y], $MachinePrecision] * z + N[Sin[y], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -14500000:\\
\;\;\;\;\mathsf{fma}\left(\cos y, z, y + x\right)\\
\mathbf{elif}\;z \leq 7.8 \cdot 10^{-19}:\\
\;\;\;\;\mathsf{fma}\left(1, z, \sin y + x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\cos y, z, \sin y\right)\\
\end{array}
\end{array}
if z < -1.45e7Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6485.0
Applied rewrites85.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6485.0
Applied rewrites85.0%
if -1.45e7 < z < 7.7999999999999999e-19Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites100.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
if 7.7999999999999999e-19 < z Initial program 99.8%
Taylor expanded in x around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-sin.f6493.1
Applied rewrites93.1%
Final simplification94.6%
(FPCore (x y z) :precision binary64 (+ (fma (cos y) z (sin y)) x))
double code(double x, double y, double z) {
return fma(cos(y), z, sin(y)) + x;
}
function code(x, y, z) return Float64(fma(cos(y), z, sin(y)) + x) end
code[x_, y_, z_] := N[(N[(N[Cos[y], $MachinePrecision] * z + N[Sin[y], $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\cos y, z, \sin y\right) + x
\end{array}
Initial program 99.9%
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.9
Applied rewrites99.9%
(FPCore (x y z)
:precision binary64
(if (<= x -2.15e-23)
(+ z x)
(if (<= x -7.5e-262)
(* (cos y) z)
(if (<= x 1.7e-16) (fma 1.0 z (sin y)) (+ z x)))))
double code(double x, double y, double z) {
double tmp;
if (x <= -2.15e-23) {
tmp = z + x;
} else if (x <= -7.5e-262) {
tmp = cos(y) * z;
} else if (x <= 1.7e-16) {
tmp = fma(1.0, z, sin(y));
} else {
tmp = z + x;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= -2.15e-23) tmp = Float64(z + x); elseif (x <= -7.5e-262) tmp = Float64(cos(y) * z); elseif (x <= 1.7e-16) tmp = fma(1.0, z, sin(y)); else tmp = Float64(z + x); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, -2.15e-23], N[(z + x), $MachinePrecision], If[LessEqual[x, -7.5e-262], N[(N[Cos[y], $MachinePrecision] * z), $MachinePrecision], If[LessEqual[x, 1.7e-16], N[(1.0 * z + N[Sin[y], $MachinePrecision]), $MachinePrecision], N[(z + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.15 \cdot 10^{-23}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;x \leq -7.5 \cdot 10^{-262}:\\
\;\;\;\;\cos y \cdot z\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{-16}:\\
\;\;\;\;\mathsf{fma}\left(1, z, \sin y\right)\\
\mathbf{else}:\\
\;\;\;\;z + x\\
\end{array}
\end{array}
if x < -2.15000000000000001e-23 or 1.7e-16 < x Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6489.8
Applied rewrites89.8%
if -2.15000000000000001e-23 < x < -7.5000000000000002e-262Initial program 99.8%
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
lift-+.f64N/A
flip-+N/A
div-invN/A
lower-*.f64N/A
lower--.f64N/A
pow2N/A
lower-pow.f64N/A
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
inv-powN/A
lower-pow.f64N/A
Applied rewrites65.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
associate-+r+N/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-sin.f6499.8
Applied rewrites99.8%
Taylor expanded in z around inf
Applied rewrites67.5%
if -7.5000000000000002e-262 < x < 1.7e-16Initial program 99.9%
Taylor expanded in y around 0
Applied rewrites82.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6482.0
Applied rewrites82.0%
Taylor expanded in x around 0
lower-sin.f6479.6
Applied rewrites79.6%
(FPCore (x y z) :precision binary64 (if (<= z -14500000.0) (fma (cos y) z (+ y x)) (if (<= z 5.3e+42) (fma 1.0 z (+ (sin y) x)) (* (cos y) z))))
double code(double x, double y, double z) {
double tmp;
if (z <= -14500000.0) {
tmp = fma(cos(y), z, (y + x));
} else if (z <= 5.3e+42) {
tmp = fma(1.0, z, (sin(y) + x));
} else {
tmp = cos(y) * z;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -14500000.0) tmp = fma(cos(y), z, Float64(y + x)); elseif (z <= 5.3e+42) tmp = fma(1.0, z, Float64(sin(y) + x)); else tmp = Float64(cos(y) * z); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -14500000.0], N[(N[Cos[y], $MachinePrecision] * z + N[(y + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.3e+42], N[(1.0 * z + N[(N[Sin[y], $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], N[(N[Cos[y], $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -14500000:\\
\;\;\;\;\mathsf{fma}\left(\cos y, z, y + x\right)\\
\mathbf{elif}\;z \leq 5.3 \cdot 10^{+42}:\\
\;\;\;\;\mathsf{fma}\left(1, z, \sin y + x\right)\\
\mathbf{else}:\\
\;\;\;\;\cos y \cdot z\\
\end{array}
\end{array}
if z < -1.45e7Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6485.0
Applied rewrites85.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6485.0
Applied rewrites85.0%
if -1.45e7 < z < 5.30000000000000028e42Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites97.0%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6497.0
Applied rewrites97.0%
if 5.30000000000000028e42 < z Initial program 99.8%
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
lift-+.f64N/A
flip-+N/A
div-invN/A
lower-*.f64N/A
lower--.f64N/A
pow2N/A
lower-pow.f64N/A
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
inv-powN/A
lower-pow.f64N/A
Applied rewrites41.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
associate-+r+N/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-sin.f6499.8
Applied rewrites99.8%
Taylor expanded in z around inf
Applied rewrites95.0%
Final simplification93.7%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* (cos y) z))) (if (<= z -7e+92) t_0 (if (<= z 5.3e+42) (fma 1.0 z (+ (sin y) x)) t_0))))
double code(double x, double y, double z) {
double t_0 = cos(y) * z;
double tmp;
if (z <= -7e+92) {
tmp = t_0;
} else if (z <= 5.3e+42) {
tmp = fma(1.0, z, (sin(y) + x));
} else {
tmp = t_0;
}
return tmp;
}
function code(x, y, z) t_0 = Float64(cos(y) * z) tmp = 0.0 if (z <= -7e+92) tmp = t_0; elseif (z <= 5.3e+42) tmp = fma(1.0, z, Float64(sin(y) + x)); else tmp = t_0; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[Cos[y], $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -7e+92], t$95$0, If[LessEqual[z, 5.3e+42], N[(1.0 * z + N[(N[Sin[y], $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos y \cdot z\\
\mathbf{if}\;z \leq -7 \cdot 10^{+92}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 5.3 \cdot 10^{+42}:\\
\;\;\;\;\mathsf{fma}\left(1, z, \sin y + x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -6.99999999999999972e92 or 5.30000000000000028e42 < z Initial program 99.8%
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
lift-+.f64N/A
flip-+N/A
div-invN/A
lower-*.f64N/A
lower--.f64N/A
pow2N/A
lower-pow.f64N/A
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
inv-powN/A
lower-pow.f64N/A
Applied rewrites37.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
associate-+r+N/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-sin.f6499.8
Applied rewrites99.8%
Taylor expanded in z around inf
Applied rewrites90.1%
if -6.99999999999999972e92 < z < 5.30000000000000028e42Initial program 100.0%
Taylor expanded in y around 0
Applied rewrites94.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6494.8
Applied rewrites94.8%
Final simplification92.9%
(FPCore (x y z) :precision binary64 (let* ((t_0 (* (cos y) z))) (if (<= z -7e+92) t_0 (if (<= z 7.8e-19) (+ z x) t_0))))
double code(double x, double y, double z) {
double t_0 = cos(y) * z;
double tmp;
if (z <= -7e+92) {
tmp = t_0;
} else if (z <= 7.8e-19) {
tmp = z + x;
} 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 = cos(y) * z
if (z <= (-7d+92)) then
tmp = t_0
else if (z <= 7.8d-19) then
tmp = z + x
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = Math.cos(y) * z;
double tmp;
if (z <= -7e+92) {
tmp = t_0;
} else if (z <= 7.8e-19) {
tmp = z + x;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z): t_0 = math.cos(y) * z tmp = 0 if z <= -7e+92: tmp = t_0 elif z <= 7.8e-19: tmp = z + x else: tmp = t_0 return tmp
function code(x, y, z) t_0 = Float64(cos(y) * z) tmp = 0.0 if (z <= -7e+92) tmp = t_0; elseif (z <= 7.8e-19) tmp = Float64(z + x); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z) t_0 = cos(y) * z; tmp = 0.0; if (z <= -7e+92) tmp = t_0; elseif (z <= 7.8e-19) tmp = z + x; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[Cos[y], $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -7e+92], t$95$0, If[LessEqual[z, 7.8e-19], N[(z + x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \cos y \cdot z\\
\mathbf{if}\;z \leq -7 \cdot 10^{+92}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 7.8 \cdot 10^{-19}:\\
\;\;\;\;z + x\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if z < -6.99999999999999972e92 or 7.7999999999999999e-19 < z Initial program 99.8%
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6499.8
Applied rewrites99.8%
lift-+.f64N/A
flip-+N/A
div-invN/A
lower-*.f64N/A
lower--.f64N/A
pow2N/A
lower-pow.f64N/A
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
inv-powN/A
lower-pow.f64N/A
Applied rewrites43.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
associate-+r+N/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-sin.f6499.8
Applied rewrites99.8%
Taylor expanded in z around inf
Applied rewrites86.2%
if -6.99999999999999972e92 < z < 7.7999999999999999e-19Initial program 100.0%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6473.6
Applied rewrites73.6%
(FPCore (x y z) :precision binary64 (if (<= y -11.0) (+ z x) (if (<= y 7500.0) (fma (fma (* -0.5 y) z 1.0) y (+ z x)) (+ z x))))
double code(double x, double y, double z) {
double tmp;
if (y <= -11.0) {
tmp = z + x;
} else if (y <= 7500.0) {
tmp = fma(fma((-0.5 * y), z, 1.0), y, (z + x));
} else {
tmp = z + x;
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (y <= -11.0) tmp = Float64(z + x); elseif (y <= 7500.0) tmp = fma(fma(Float64(-0.5 * y), z, 1.0), y, Float64(z + x)); else tmp = Float64(z + x); end return tmp end
code[x_, y_, z_] := If[LessEqual[y, -11.0], N[(z + x), $MachinePrecision], If[LessEqual[y, 7500.0], N[(N[(N[(-0.5 * y), $MachinePrecision] * z + 1.0), $MachinePrecision] * y + N[(z + x), $MachinePrecision]), $MachinePrecision], N[(z + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -11:\\
\;\;\;\;z + x\\
\mathbf{elif}\;y \leq 7500:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-0.5 \cdot y, z, 1\right), y, z + x\right)\\
\mathbf{else}:\\
\;\;\;\;z + x\\
\end{array}
\end{array}
if y < -11 or 7500 < y Initial program 99.8%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6442.8
Applied rewrites42.8%
if -11 < y < 7500Initial program 100.0%
Taylor expanded in y around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6499.3
Applied rewrites99.3%
(FPCore (x y z) :precision binary64 (if (<= y -1.05e+61) (+ z x) (if (<= y 4.6e+65) (+ (+ y x) z) (+ z x))))
double code(double x, double y, double z) {
double tmp;
if (y <= -1.05e+61) {
tmp = z + x;
} else if (y <= 4.6e+65) {
tmp = (y + x) + z;
} else {
tmp = z + x;
}
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 <= (-1.05d+61)) then
tmp = z + x
else if (y <= 4.6d+65) then
tmp = (y + x) + z
else
tmp = z + x
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= -1.05e+61) {
tmp = z + x;
} else if (y <= 4.6e+65) {
tmp = (y + x) + z;
} else {
tmp = z + x;
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= -1.05e+61: tmp = z + x elif y <= 4.6e+65: tmp = (y + x) + z else: tmp = z + x return tmp
function code(x, y, z) tmp = 0.0 if (y <= -1.05e+61) tmp = Float64(z + x); elseif (y <= 4.6e+65) tmp = Float64(Float64(y + x) + z); else tmp = Float64(z + x); end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= -1.05e+61) tmp = z + x; elseif (y <= 4.6e+65) tmp = (y + x) + z; else tmp = z + x; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, -1.05e+61], N[(z + x), $MachinePrecision], If[LessEqual[y, 4.6e+65], N[(N[(y + x), $MachinePrecision] + z), $MachinePrecision], N[(z + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.05 \cdot 10^{+61}:\\
\;\;\;\;z + x\\
\mathbf{elif}\;y \leq 4.6 \cdot 10^{+65}:\\
\;\;\;\;\left(y + x\right) + z\\
\mathbf{else}:\\
\;\;\;\;z + x\\
\end{array}
\end{array}
if y < -1.0500000000000001e61 or 4.6e65 < y Initial program 99.8%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6443.2
Applied rewrites43.2%
if -1.0500000000000001e61 < y < 4.6e65Initial program 100.0%
Taylor expanded in y around 0
associate-+r+N/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f6486.5
Applied rewrites86.5%
(FPCore (x y z) :precision binary64 (+ z x))
double code(double x, double y, double z) {
return z + x;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = z + x
end function
public static double code(double x, double y, double z) {
return z + x;
}
def code(x, y, z): return z + x
function code(x, y, z) return Float64(z + x) end
function tmp = code(x, y, z) tmp = z + x; end
code[x_, y_, z_] := N[(z + x), $MachinePrecision]
\begin{array}{l}
\\
z + x
\end{array}
Initial program 99.9%
Taylor expanded in y around 0
+-commutativeN/A
lower-+.f6468.3
Applied rewrites68.3%
herbie shell --seed 2024296
(FPCore (x y z)
:name "Graphics.Rasterific.Svg.PathConverter:segmentToBezier from rasterific-svg-0.2.3.1, C"
:precision binary64
(+ (+ x (sin y)) (* z (cos y))))