
(FPCore (x y) :precision binary64 (* (* 3.0 (sqrt x)) (- (+ y (/ 1.0 (* x 9.0))) 1.0)))
double code(double x, double y) {
return (3.0 * sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (3.0d0 * sqrt(x)) * ((y + (1.0d0 / (x * 9.0d0))) - 1.0d0)
end function
public static double code(double x, double y) {
return (3.0 * Math.sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0);
}
def code(x, y): return (3.0 * math.sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0)
function code(x, y) return Float64(Float64(3.0 * sqrt(x)) * Float64(Float64(y + Float64(1.0 / Float64(x * 9.0))) - 1.0)) end
function tmp = code(x, y) tmp = (3.0 * sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0); end
code[x_, y_] := N[(N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * N[(N[(y + N[(1.0 / N[(x * 9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(3 \cdot \sqrt{x}\right) \cdot \left(\left(y + \frac{1}{x \cdot 9}\right) - 1\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (* (* 3.0 (sqrt x)) (- (+ y (/ 1.0 (* x 9.0))) 1.0)))
double code(double x, double y) {
return (3.0 * sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (3.0d0 * sqrt(x)) * ((y + (1.0d0 / (x * 9.0d0))) - 1.0d0)
end function
public static double code(double x, double y) {
return (3.0 * Math.sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0);
}
def code(x, y): return (3.0 * math.sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0)
function code(x, y) return Float64(Float64(3.0 * sqrt(x)) * Float64(Float64(y + Float64(1.0 / Float64(x * 9.0))) - 1.0)) end
function tmp = code(x, y) tmp = (3.0 * sqrt(x)) * ((y + (1.0 / (x * 9.0))) - 1.0); end
code[x_, y_] := N[(N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * N[(N[(y + N[(1.0 / N[(x * 9.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(3 \cdot \sqrt{x}\right) \cdot \left(\left(y + \frac{1}{x \cdot 9}\right) - 1\right)
\end{array}
(FPCore (x y) :precision binary64 (fma (fma 3.0 y -3.0) (sqrt x) (/ 0.3333333333333333 (sqrt x))))
double code(double x, double y) {
return fma(fma(3.0, y, -3.0), sqrt(x), (0.3333333333333333 / sqrt(x)));
}
function code(x, y) return fma(fma(3.0, y, -3.0), sqrt(x), Float64(0.3333333333333333 / sqrt(x))) end
code[x_, y_] := N[(N[(3.0 * y + -3.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision] + N[(0.3333333333333333 / N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\mathsf{fma}\left(3, y, -3\right), \sqrt{x}, \frac{0.3333333333333333}{\sqrt{x}}\right)
\end{array}
Initial program 99.5%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
metadata-evalN/A
metadata-evalN/A
lower-fma.f64N/A
metadata-evalN/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
Applied rewrites99.5%
Taylor expanded in y around 0
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
+-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-out--N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-sqrt.f6499.5
Applied rewrites99.5%
Applied rewrites99.6%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* 3.0 (sqrt x)))
(t_1 (* t_0 (- (+ y (pow (* x 9.0) -1.0)) 1.0))))
(if (<= t_1 -1.0)
(* (fma 3.0 y -3.0) (sqrt x))
(if (<= t_1 1e+153)
(* (sqrt (pow x -1.0)) 0.3333333333333333)
(* t_0 y)))))
double code(double x, double y) {
double t_0 = 3.0 * sqrt(x);
double t_1 = t_0 * ((y + pow((x * 9.0), -1.0)) - 1.0);
double tmp;
if (t_1 <= -1.0) {
tmp = fma(3.0, y, -3.0) * sqrt(x);
} else if (t_1 <= 1e+153) {
tmp = sqrt(pow(x, -1.0)) * 0.3333333333333333;
} else {
tmp = t_0 * y;
}
return tmp;
}
function code(x, y) t_0 = Float64(3.0 * sqrt(x)) t_1 = Float64(t_0 * Float64(Float64(y + (Float64(x * 9.0) ^ -1.0)) - 1.0)) tmp = 0.0 if (t_1 <= -1.0) tmp = Float64(fma(3.0, y, -3.0) * sqrt(x)); elseif (t_1 <= 1e+153) tmp = Float64(sqrt((x ^ -1.0)) * 0.3333333333333333); else tmp = Float64(t_0 * y); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[(N[(y + N[Power[N[(x * 9.0), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1.0], N[(N[(3.0 * y + -3.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+153], N[(N[Sqrt[N[Power[x, -1.0], $MachinePrecision]], $MachinePrecision] * 0.3333333333333333), $MachinePrecision], N[(t$95$0 * y), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 3 \cdot \sqrt{x}\\
t_1 := t\_0 \cdot \left(\left(y + {\left(x \cdot 9\right)}^{-1}\right) - 1\right)\\
\mathbf{if}\;t\_1 \leq -1:\\
\;\;\;\;\mathsf{fma}\left(3, y, -3\right) \cdot \sqrt{x}\\
\mathbf{elif}\;t\_1 \leq 10^{+153}:\\
\;\;\;\;\sqrt{{x}^{-1}} \cdot 0.3333333333333333\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot y\\
\end{array}
\end{array}
if (*.f64 (*.f64 #s(literal 3 binary64) (sqrt.f64 x)) (-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) (*.f64 x #s(literal 9 binary64)))) #s(literal 1 binary64))) < -1Initial program 99.6%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-sqrt.f6497.2
Applied rewrites97.2%
if -1 < (*.f64 (*.f64 #s(literal 3 binary64) (sqrt.f64 x)) (-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) (*.f64 x #s(literal 9 binary64)))) #s(literal 1 binary64))) < 1e153Initial program 99.3%
Taylor expanded in x around 0
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f6481.7
Applied rewrites81.7%
if 1e153 < (*.f64 (*.f64 #s(literal 3 binary64) (sqrt.f64 x)) (-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) (*.f64 x #s(literal 9 binary64)))) #s(literal 1 binary64))) Initial program 99.8%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f6499.7
Applied rewrites99.7%
Applied rewrites99.8%
Final simplification91.2%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* 3.0 (sqrt x)))
(t_1 (* t_0 (- (+ y (pow (* x 9.0) -1.0)) 1.0))))
(if (<= t_1 -2000000.0)
(* (fma 3.0 y -3.0) (sqrt x))
(if (<= t_1 1e+153)
(* (sqrt x) (- (/ 0.3333333333333333 x) 3.0))
(* t_0 y)))))
double code(double x, double y) {
double t_0 = 3.0 * sqrt(x);
double t_1 = t_0 * ((y + pow((x * 9.0), -1.0)) - 1.0);
double tmp;
if (t_1 <= -2000000.0) {
tmp = fma(3.0, y, -3.0) * sqrt(x);
} else if (t_1 <= 1e+153) {
tmp = sqrt(x) * ((0.3333333333333333 / x) - 3.0);
} else {
tmp = t_0 * y;
}
return tmp;
}
function code(x, y) t_0 = Float64(3.0 * sqrt(x)) t_1 = Float64(t_0 * Float64(Float64(y + (Float64(x * 9.0) ^ -1.0)) - 1.0)) tmp = 0.0 if (t_1 <= -2000000.0) tmp = Float64(fma(3.0, y, -3.0) * sqrt(x)); elseif (t_1 <= 1e+153) tmp = Float64(sqrt(x) * Float64(Float64(0.3333333333333333 / x) - 3.0)); else tmp = Float64(t_0 * y); end return tmp end
code[x_, y_] := Block[{t$95$0 = N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[(N[(y + N[Power[N[(x * 9.0), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2000000.0], N[(N[(3.0 * y + -3.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e+153], N[(N[Sqrt[x], $MachinePrecision] * N[(N[(0.3333333333333333 / x), $MachinePrecision] - 3.0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * y), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 3 \cdot \sqrt{x}\\
t_1 := t\_0 \cdot \left(\left(y + {\left(x \cdot 9\right)}^{-1}\right) - 1\right)\\
\mathbf{if}\;t\_1 \leq -2000000:\\
\;\;\;\;\mathsf{fma}\left(3, y, -3\right) \cdot \sqrt{x}\\
\mathbf{elif}\;t\_1 \leq 10^{+153}:\\
\;\;\;\;\sqrt{x} \cdot \left(\frac{0.3333333333333333}{x} - 3\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot y\\
\end{array}
\end{array}
if (*.f64 (*.f64 #s(literal 3 binary64) (sqrt.f64 x)) (-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) (*.f64 x #s(literal 9 binary64)))) #s(literal 1 binary64))) < -2e6Initial program 99.6%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-sqrt.f6498.3
Applied rewrites98.3%
if -2e6 < (*.f64 (*.f64 #s(literal 3 binary64) (sqrt.f64 x)) (-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) (*.f64 x #s(literal 9 binary64)))) #s(literal 1 binary64))) < 1e153Initial program 99.3%
Taylor expanded in y around 0
associate-*r*N/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*l*N/A
associate-*r/N/A
metadata-evalN/A
associate-*r/N/A
metadata-evalN/A
metadata-evalN/A
associate-*l/N/A
metadata-evalN/A
associate-*r/N/A
*-rgt-identityN/A
*-commutativeN/A
distribute-lft-out--N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower--.f64N/A
Applied rewrites82.3%
if 1e153 < (*.f64 (*.f64 #s(literal 3 binary64) (sqrt.f64 x)) (-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) (*.f64 x #s(literal 9 binary64)))) #s(literal 1 binary64))) Initial program 99.8%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f6499.7
Applied rewrites99.7%
Applied rewrites99.8%
Final simplification91.8%
(FPCore (x y) :precision binary64 (* (fma (- 1.0 y) -3.0 (pow (* x 3.0) -1.0)) (sqrt x)))
double code(double x, double y) {
return fma((1.0 - y), -3.0, pow((x * 3.0), -1.0)) * sqrt(x);
}
function code(x, y) return Float64(fma(Float64(1.0 - y), -3.0, (Float64(x * 3.0) ^ -1.0)) * sqrt(x)) end
code[x_, y_] := N[(N[(N[(1.0 - y), $MachinePrecision] * -3.0 + N[Power[N[(x * 3.0), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(1 - y, -3, {\left(x \cdot 3\right)}^{-1}\right) \cdot \sqrt{x}
\end{array}
Initial program 99.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lift--.f64N/A
sub-negN/A
metadata-evalN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
lower-/.f64N/A
metadata-evalN/A
metadata-eval99.4
Applied rewrites99.4%
Taylor expanded in x around inf
+-commutativeN/A
associate--l+N/A
+-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-outN/A
mul-1-negN/A
rem-square-sqrtN/A
unpow2N/A
*-commutativeN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites99.5%
Applied rewrites99.5%
Final simplification99.5%
(FPCore (x y) :precision binary64 (if (<= x 3e-8) (* (fma (- y) -3.0 (/ 0.3333333333333333 x)) (sqrt x)) (* (fma 3.0 y -3.0) (sqrt x))))
double code(double x, double y) {
double tmp;
if (x <= 3e-8) {
tmp = fma(-y, -3.0, (0.3333333333333333 / x)) * sqrt(x);
} else {
tmp = fma(3.0, y, -3.0) * sqrt(x);
}
return tmp;
}
function code(x, y) tmp = 0.0 if (x <= 3e-8) tmp = Float64(fma(Float64(-y), -3.0, Float64(0.3333333333333333 / x)) * sqrt(x)); else tmp = Float64(fma(3.0, y, -3.0) * sqrt(x)); end return tmp end
code[x_, y_] := If[LessEqual[x, 3e-8], N[(N[((-y) * -3.0 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision], N[(N[(3.0 * y + -3.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 3 \cdot 10^{-8}:\\
\;\;\;\;\mathsf{fma}\left(-y, -3, \frac{0.3333333333333333}{x}\right) \cdot \sqrt{x}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(3, y, -3\right) \cdot \sqrt{x}\\
\end{array}
\end{array}
if x < 2.99999999999999973e-8Initial program 99.3%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lift--.f64N/A
sub-negN/A
metadata-evalN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
lower-/.f64N/A
metadata-evalN/A
metadata-eval99.1
Applied rewrites99.1%
Taylor expanded in x around inf
+-commutativeN/A
associate--l+N/A
+-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-outN/A
mul-1-negN/A
rem-square-sqrtN/A
unpow2N/A
*-commutativeN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites99.3%
Taylor expanded in y around inf
Applied rewrites98.6%
if 2.99999999999999973e-8 < x Initial program 99.6%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-sqrt.f6498.6
Applied rewrites98.6%
(FPCore (x y) :precision binary64 (* (fma (- 1.0 y) -3.0 (/ 0.3333333333333333 x)) (sqrt x)))
double code(double x, double y) {
return fma((1.0 - y), -3.0, (0.3333333333333333 / x)) * sqrt(x);
}
function code(x, y) return Float64(fma(Float64(1.0 - y), -3.0, Float64(0.3333333333333333 / x)) * sqrt(x)) end
code[x_, y_] := N[(N[(N[(1.0 - y), $MachinePrecision] * -3.0 + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(1 - y, -3, \frac{0.3333333333333333}{x}\right) \cdot \sqrt{x}
\end{array}
Initial program 99.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lift--.f64N/A
sub-negN/A
metadata-evalN/A
distribute-rgt-inN/A
lower-fma.f64N/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/r*N/A
metadata-evalN/A
metadata-evalN/A
lower-/.f64N/A
metadata-evalN/A
metadata-eval99.4
Applied rewrites99.4%
Taylor expanded in x around inf
+-commutativeN/A
associate--l+N/A
+-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-outN/A
mul-1-negN/A
rem-square-sqrtN/A
unpow2N/A
*-commutativeN/A
metadata-evalN/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
*-commutativeN/A
distribute-lft1-inN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites99.5%
(FPCore (x y) :precision binary64 (* (sqrt x) (- (fma 3.0 y (/ 0.3333333333333333 x)) 3.0)))
double code(double x, double y) {
return sqrt(x) * (fma(3.0, y, (0.3333333333333333 / x)) - 3.0);
}
function code(x, y) return Float64(sqrt(x) * Float64(fma(3.0, y, Float64(0.3333333333333333 / x)) - 3.0)) end
code[x_, y_] := N[(N[Sqrt[x], $MachinePrecision] * N[(N[(3.0 * y + N[(0.3333333333333333 / x), $MachinePrecision]), $MachinePrecision] - 3.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{x} \cdot \left(\mathsf{fma}\left(3, y, \frac{0.3333333333333333}{x}\right) - 3\right)
\end{array}
Initial program 99.5%
Taylor expanded in y around 0
associate-*r*N/A
sub-negN/A
metadata-evalN/A
distribute-rgt-inN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
unsub-negN/A
Applied rewrites99.5%
(FPCore (x y) :precision binary64 (* (fma 3.0 y -3.0) (sqrt x)))
double code(double x, double y) {
return fma(3.0, y, -3.0) * sqrt(x);
}
function code(x, y) return Float64(fma(3.0, y, -3.0) * sqrt(x)) end
code[x_, y_] := N[(N[(3.0 * y + -3.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(3, y, -3\right) \cdot \sqrt{x}
\end{array}
Initial program 99.5%
Taylor expanded in x around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
sub-negN/A
metadata-evalN/A
distribute-lft-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-sqrt.f6465.7
Applied rewrites65.7%
(FPCore (x y) :precision binary64 (* (* y 3.0) (sqrt x)))
double code(double x, double y) {
return (y * 3.0) * sqrt(x);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (y * 3.0d0) * sqrt(x)
end function
public static double code(double x, double y) {
return (y * 3.0) * Math.sqrt(x);
}
def code(x, y): return (y * 3.0) * math.sqrt(x)
function code(x, y) return Float64(Float64(y * 3.0) * sqrt(x)) end
function tmp = code(x, y) tmp = (y * 3.0) * sqrt(x); end
code[x_, y_] := N[(N[(y * 3.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(y \cdot 3\right) \cdot \sqrt{x}
\end{array}
Initial program 99.5%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f6440.6
Applied rewrites40.6%
Applied rewrites40.6%
(FPCore (x y) :precision binary64 (* (* 3.0 (sqrt x)) y))
double code(double x, double y) {
return (3.0 * sqrt(x)) * y;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (3.0d0 * sqrt(x)) * y
end function
public static double code(double x, double y) {
return (3.0 * Math.sqrt(x)) * y;
}
def code(x, y): return (3.0 * math.sqrt(x)) * y
function code(x, y) return Float64(Float64(3.0 * sqrt(x)) * y) end
function tmp = code(x, y) tmp = (3.0 * sqrt(x)) * y; end
code[x_, y_] := N[(N[(3.0 * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]
\begin{array}{l}
\\
\left(3 \cdot \sqrt{x}\right) \cdot y
\end{array}
Initial program 99.5%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f6440.6
Applied rewrites40.6%
Applied rewrites40.6%
(FPCore (x y) :precision binary64 (* 3.0 (+ (* y (sqrt x)) (* (- (/ 1.0 (* x 9.0)) 1.0) (sqrt x)))))
double code(double x, double y) {
return 3.0 * ((y * sqrt(x)) + (((1.0 / (x * 9.0)) - 1.0) * sqrt(x)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 3.0d0 * ((y * sqrt(x)) + (((1.0d0 / (x * 9.0d0)) - 1.0d0) * sqrt(x)))
end function
public static double code(double x, double y) {
return 3.0 * ((y * Math.sqrt(x)) + (((1.0 / (x * 9.0)) - 1.0) * Math.sqrt(x)));
}
def code(x, y): return 3.0 * ((y * math.sqrt(x)) + (((1.0 / (x * 9.0)) - 1.0) * math.sqrt(x)))
function code(x, y) return Float64(3.0 * Float64(Float64(y * sqrt(x)) + Float64(Float64(Float64(1.0 / Float64(x * 9.0)) - 1.0) * sqrt(x)))) end
function tmp = code(x, y) tmp = 3.0 * ((y * sqrt(x)) + (((1.0 / (x * 9.0)) - 1.0) * sqrt(x))); end
code[x_, y_] := N[(3.0 * N[(N[(y * N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[(N[(1.0 / N[(x * 9.0), $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision] * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
3 \cdot \left(y \cdot \sqrt{x} + \left(\frac{1}{x \cdot 9} - 1\right) \cdot \sqrt{x}\right)
\end{array}
herbie shell --seed 2024313
(FPCore (x y)
:name "Numeric.SpecFunctions:incompleteGamma from math-functions-0.1.5.2, B"
:precision binary64
:alt
(! :herbie-platform default (* 3 (+ (* y (sqrt x)) (* (- (/ 1 (* x 9)) 1) (sqrt x)))))
(* (* 3.0 (sqrt x)) (- (+ y (/ 1.0 (* x 9.0))) 1.0)))