
(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 11 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 (* (sqrt (* x 9.0)) (+ (/ 0.1111111111111111 x) (+ y -1.0))))
double code(double x, double y) {
return sqrt((x * 9.0)) * ((0.1111111111111111 / x) + (y + -1.0));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt((x * 9.0d0)) * ((0.1111111111111111d0 / x) + (y + (-1.0d0)))
end function
public static double code(double x, double y) {
return Math.sqrt((x * 9.0)) * ((0.1111111111111111 / x) + (y + -1.0));
}
def code(x, y): return math.sqrt((x * 9.0)) * ((0.1111111111111111 / x) + (y + -1.0))
function code(x, y) return Float64(sqrt(Float64(x * 9.0)) * Float64(Float64(0.1111111111111111 / x) + Float64(y + -1.0))) end
function tmp = code(x, y) tmp = sqrt((x * 9.0)) * ((0.1111111111111111 / x) + (y + -1.0)); end
code[x_, y_] := N[(N[Sqrt[N[(x * 9.0), $MachinePrecision]], $MachinePrecision] * N[(N[(0.1111111111111111 / x), $MachinePrecision] + N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{x \cdot 9} \cdot \left(\frac{0.1111111111111111}{x} + \left(y + -1\right)\right)
\end{array}
Initial program 99.4%
+-commutative99.4%
associate--l+99.4%
*-commutative99.4%
associate-/r*99.3%
metadata-eval99.3%
sub-neg99.3%
metadata-eval99.3%
Simplified99.3%
*-commutative99.3%
metadata-eval99.3%
sqrt-prod99.5%
pow1/299.5%
Applied egg-rr99.5%
unpow1/299.5%
Simplified99.5%
Final simplification99.5%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* (sqrt x) -3.0))
(t_1 (* 3.0 (* y (sqrt x))))
(t_2 (sqrt (/ 0.1111111111111111 x))))
(if (<= y -1.6e+56)
t_1
(if (<= y -2.35e-180)
t_2
(if (<= y -1.1e-238)
t_0
(if (<= y 8e-148)
t_2
(if (<= y 9.5e-45) t_0 (if (<= y 2e+91) t_2 t_1))))))))
double code(double x, double y) {
double t_0 = sqrt(x) * -3.0;
double t_1 = 3.0 * (y * sqrt(x));
double t_2 = sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -1.6e+56) {
tmp = t_1;
} else if (y <= -2.35e-180) {
tmp = t_2;
} else if (y <= -1.1e-238) {
tmp = t_0;
} else if (y <= 8e-148) {
tmp = t_2;
} else if (y <= 9.5e-45) {
tmp = t_0;
} else if (y <= 2e+91) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = sqrt(x) * (-3.0d0)
t_1 = 3.0d0 * (y * sqrt(x))
t_2 = sqrt((0.1111111111111111d0 / x))
if (y <= (-1.6d+56)) then
tmp = t_1
else if (y <= (-2.35d-180)) then
tmp = t_2
else if (y <= (-1.1d-238)) then
tmp = t_0
else if (y <= 8d-148) then
tmp = t_2
else if (y <= 9.5d-45) then
tmp = t_0
else if (y <= 2d+91) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.sqrt(x) * -3.0;
double t_1 = 3.0 * (y * Math.sqrt(x));
double t_2 = Math.sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -1.6e+56) {
tmp = t_1;
} else if (y <= -2.35e-180) {
tmp = t_2;
} else if (y <= -1.1e-238) {
tmp = t_0;
} else if (y <= 8e-148) {
tmp = t_2;
} else if (y <= 9.5e-45) {
tmp = t_0;
} else if (y <= 2e+91) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y): t_0 = math.sqrt(x) * -3.0 t_1 = 3.0 * (y * math.sqrt(x)) t_2 = math.sqrt((0.1111111111111111 / x)) tmp = 0 if y <= -1.6e+56: tmp = t_1 elif y <= -2.35e-180: tmp = t_2 elif y <= -1.1e-238: tmp = t_0 elif y <= 8e-148: tmp = t_2 elif y <= 9.5e-45: tmp = t_0 elif y <= 2e+91: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y) t_0 = Float64(sqrt(x) * -3.0) t_1 = Float64(3.0 * Float64(y * sqrt(x))) t_2 = sqrt(Float64(0.1111111111111111 / x)) tmp = 0.0 if (y <= -1.6e+56) tmp = t_1; elseif (y <= -2.35e-180) tmp = t_2; elseif (y <= -1.1e-238) tmp = t_0; elseif (y <= 8e-148) tmp = t_2; elseif (y <= 9.5e-45) tmp = t_0; elseif (y <= 2e+91) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y) t_0 = sqrt(x) * -3.0; t_1 = 3.0 * (y * sqrt(x)); t_2 = sqrt((0.1111111111111111 / x)); tmp = 0.0; if (y <= -1.6e+56) tmp = t_1; elseif (y <= -2.35e-180) tmp = t_2; elseif (y <= -1.1e-238) tmp = t_0; elseif (y <= 8e-148) tmp = t_2; elseif (y <= 9.5e-45) tmp = t_0; elseif (y <= 2e+91) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[Sqrt[x], $MachinePrecision] * -3.0), $MachinePrecision]}, Block[{t$95$1 = N[(3.0 * N[(y * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(0.1111111111111111 / x), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y, -1.6e+56], t$95$1, If[LessEqual[y, -2.35e-180], t$95$2, If[LessEqual[y, -1.1e-238], t$95$0, If[LessEqual[y, 8e-148], t$95$2, If[LessEqual[y, 9.5e-45], t$95$0, If[LessEqual[y, 2e+91], t$95$2, t$95$1]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{x} \cdot -3\\
t_1 := 3 \cdot \left(y \cdot \sqrt{x}\right)\\
t_2 := \sqrt{\frac{0.1111111111111111}{x}}\\
\mathbf{if}\;y \leq -1.6 \cdot 10^{+56}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -2.35 \cdot 10^{-180}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -1.1 \cdot 10^{-238}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 8 \cdot 10^{-148}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 9.5 \cdot 10^{-45}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+91}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.60000000000000002e56 or 2.00000000000000016e91 < y Initial program 99.4%
*-commutative99.4%
associate-*l*99.5%
associate--l+99.5%
distribute-lft-in99.5%
fma-define99.4%
sub-neg99.4%
+-commutative99.4%
distribute-lft-in99.4%
metadata-eval99.4%
metadata-eval99.4%
*-commutative99.4%
associate-/r*99.4%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in y around inf 82.1%
if -1.60000000000000002e56 < y < -2.34999999999999988e-180 or -1.09999999999999996e-238 < y < 7.99999999999999949e-148 or 9.5000000000000002e-45 < y < 2.00000000000000016e91Initial program 99.3%
*-commutative99.3%
associate-*l*99.3%
associate--l+99.3%
distribute-lft-in99.3%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.3%
metadata-eval99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.3%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
add-sqr-sqrt68.7%
sqrt-unprod68.5%
swap-sqr34.7%
add-sqr-sqrt34.7%
pow234.7%
+-commutative34.7%
Applied egg-rr34.7%
Taylor expanded in x around 0 61.0%
if -2.34999999999999988e-180 < y < -1.09999999999999996e-238 or 7.99999999999999949e-148 < y < 9.5000000000000002e-45Initial program 99.5%
+-commutative99.5%
associate--l+99.5%
*-commutative99.5%
associate-/r*99.4%
metadata-eval99.4%
sub-neg99.4%
metadata-eval99.4%
Simplified99.4%
*-commutative99.4%
metadata-eval99.4%
sqrt-prod99.7%
pow1/299.7%
Applied egg-rr99.7%
unpow1/299.7%
Simplified99.7%
Taylor expanded in x around inf 70.9%
Taylor expanded in y around 0 70.7%
*-commutative70.7%
Simplified70.7%
Final simplification70.7%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* (sqrt x) -3.0)) (t_1 (sqrt (/ 0.1111111111111111 x))))
(if (<= y -3.5e+63)
(* (sqrt x) (* y 3.0))
(if (<= y -2.8e-182)
t_1
(if (<= y -6.8e-239)
t_0
(if (<= y 1.18e-147)
t_1
(if (<= y 2.25e-45)
t_0
(if (<= y 3.3e+91) t_1 (* 3.0 (* y (sqrt x)))))))))))
double code(double x, double y) {
double t_0 = sqrt(x) * -3.0;
double t_1 = sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -3.5e+63) {
tmp = sqrt(x) * (y * 3.0);
} else if (y <= -2.8e-182) {
tmp = t_1;
} else if (y <= -6.8e-239) {
tmp = t_0;
} else if (y <= 1.18e-147) {
tmp = t_1;
} else if (y <= 2.25e-45) {
tmp = t_0;
} else if (y <= 3.3e+91) {
tmp = t_1;
} else {
tmp = 3.0 * (y * sqrt(x));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = sqrt(x) * (-3.0d0)
t_1 = sqrt((0.1111111111111111d0 / x))
if (y <= (-3.5d+63)) then
tmp = sqrt(x) * (y * 3.0d0)
else if (y <= (-2.8d-182)) then
tmp = t_1
else if (y <= (-6.8d-239)) then
tmp = t_0
else if (y <= 1.18d-147) then
tmp = t_1
else if (y <= 2.25d-45) then
tmp = t_0
else if (y <= 3.3d+91) then
tmp = t_1
else
tmp = 3.0d0 * (y * sqrt(x))
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.sqrt(x) * -3.0;
double t_1 = Math.sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -3.5e+63) {
tmp = Math.sqrt(x) * (y * 3.0);
} else if (y <= -2.8e-182) {
tmp = t_1;
} else if (y <= -6.8e-239) {
tmp = t_0;
} else if (y <= 1.18e-147) {
tmp = t_1;
} else if (y <= 2.25e-45) {
tmp = t_0;
} else if (y <= 3.3e+91) {
tmp = t_1;
} else {
tmp = 3.0 * (y * Math.sqrt(x));
}
return tmp;
}
def code(x, y): t_0 = math.sqrt(x) * -3.0 t_1 = math.sqrt((0.1111111111111111 / x)) tmp = 0 if y <= -3.5e+63: tmp = math.sqrt(x) * (y * 3.0) elif y <= -2.8e-182: tmp = t_1 elif y <= -6.8e-239: tmp = t_0 elif y <= 1.18e-147: tmp = t_1 elif y <= 2.25e-45: tmp = t_0 elif y <= 3.3e+91: tmp = t_1 else: tmp = 3.0 * (y * math.sqrt(x)) return tmp
function code(x, y) t_0 = Float64(sqrt(x) * -3.0) t_1 = sqrt(Float64(0.1111111111111111 / x)) tmp = 0.0 if (y <= -3.5e+63) tmp = Float64(sqrt(x) * Float64(y * 3.0)); elseif (y <= -2.8e-182) tmp = t_1; elseif (y <= -6.8e-239) tmp = t_0; elseif (y <= 1.18e-147) tmp = t_1; elseif (y <= 2.25e-45) tmp = t_0; elseif (y <= 3.3e+91) tmp = t_1; else tmp = Float64(3.0 * Float64(y * sqrt(x))); end return tmp end
function tmp_2 = code(x, y) t_0 = sqrt(x) * -3.0; t_1 = sqrt((0.1111111111111111 / x)); tmp = 0.0; if (y <= -3.5e+63) tmp = sqrt(x) * (y * 3.0); elseif (y <= -2.8e-182) tmp = t_1; elseif (y <= -6.8e-239) tmp = t_0; elseif (y <= 1.18e-147) tmp = t_1; elseif (y <= 2.25e-45) tmp = t_0; elseif (y <= 3.3e+91) tmp = t_1; else tmp = 3.0 * (y * sqrt(x)); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[Sqrt[x], $MachinePrecision] * -3.0), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(0.1111111111111111 / x), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y, -3.5e+63], N[(N[Sqrt[x], $MachinePrecision] * N[(y * 3.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2.8e-182], t$95$1, If[LessEqual[y, -6.8e-239], t$95$0, If[LessEqual[y, 1.18e-147], t$95$1, If[LessEqual[y, 2.25e-45], t$95$0, If[LessEqual[y, 3.3e+91], t$95$1, N[(3.0 * N[(y * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{x} \cdot -3\\
t_1 := \sqrt{\frac{0.1111111111111111}{x}}\\
\mathbf{if}\;y \leq -3.5 \cdot 10^{+63}:\\
\;\;\;\;\sqrt{x} \cdot \left(y \cdot 3\right)\\
\mathbf{elif}\;y \leq -2.8 \cdot 10^{-182}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -6.8 \cdot 10^{-239}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 1.18 \cdot 10^{-147}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.25 \cdot 10^{-45}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;3 \cdot \left(y \cdot \sqrt{x}\right)\\
\end{array}
\end{array}
if y < -3.50000000000000029e63Initial program 99.5%
*-commutative99.5%
associate-*l*99.5%
associate--l+99.5%
distribute-lft-in99.5%
fma-define99.5%
sub-neg99.5%
+-commutative99.5%
distribute-lft-in99.5%
metadata-eval99.5%
metadata-eval99.5%
*-commutative99.5%
associate-/r*99.5%
associate-*r/99.5%
metadata-eval99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in y around inf 79.4%
*-commutative79.4%
associate-*l*79.6%
*-commutative79.6%
Simplified79.6%
if -3.50000000000000029e63 < y < -2.79999999999999993e-182 or -6.8e-239 < y < 1.18000000000000003e-147 or 2.2499999999999999e-45 < y < 3.30000000000000017e91Initial program 99.3%
*-commutative99.3%
associate-*l*99.3%
associate--l+99.3%
distribute-lft-in99.3%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.3%
metadata-eval99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.3%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
add-sqr-sqrt68.7%
sqrt-unprod68.5%
swap-sqr34.7%
add-sqr-sqrt34.7%
pow234.7%
+-commutative34.7%
Applied egg-rr34.7%
Taylor expanded in x around 0 61.0%
if -2.79999999999999993e-182 < y < -6.8e-239 or 1.18000000000000003e-147 < y < 2.2499999999999999e-45Initial program 99.5%
+-commutative99.5%
associate--l+99.5%
*-commutative99.5%
associate-/r*99.4%
metadata-eval99.4%
sub-neg99.4%
metadata-eval99.4%
Simplified99.4%
*-commutative99.4%
metadata-eval99.4%
sqrt-prod99.7%
pow1/299.7%
Applied egg-rr99.7%
unpow1/299.7%
Simplified99.7%
Taylor expanded in x around inf 70.9%
Taylor expanded in y around 0 70.7%
*-commutative70.7%
Simplified70.7%
if 3.30000000000000017e91 < y Initial program 99.3%
*-commutative99.3%
associate-*l*99.4%
associate--l+99.4%
distribute-lft-in99.4%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.3%
metadata-eval99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.4%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in y around inf 85.5%
Final simplification70.7%
(FPCore (x y)
:precision binary64
(let* ((t_0 (- (sqrt (* x 9.0)))) (t_1 (sqrt (/ 0.1111111111111111 x))))
(if (<= y -5e+52)
(* (sqrt x) (* y 3.0))
(if (<= y -3.7e-184)
t_1
(if (<= y -4.4e-238)
t_0
(if (<= y 1.3e-147)
t_1
(if (<= y 1.9e-44)
t_0
(if (<= y 2e+91) t_1 (* 3.0 (* y (sqrt x)))))))))))
double code(double x, double y) {
double t_0 = -sqrt((x * 9.0));
double t_1 = sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -5e+52) {
tmp = sqrt(x) * (y * 3.0);
} else if (y <= -3.7e-184) {
tmp = t_1;
} else if (y <= -4.4e-238) {
tmp = t_0;
} else if (y <= 1.3e-147) {
tmp = t_1;
} else if (y <= 1.9e-44) {
tmp = t_0;
} else if (y <= 2e+91) {
tmp = t_1;
} else {
tmp = 3.0 * (y * sqrt(x));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = -sqrt((x * 9.0d0))
t_1 = sqrt((0.1111111111111111d0 / x))
if (y <= (-5d+52)) then
tmp = sqrt(x) * (y * 3.0d0)
else if (y <= (-3.7d-184)) then
tmp = t_1
else if (y <= (-4.4d-238)) then
tmp = t_0
else if (y <= 1.3d-147) then
tmp = t_1
else if (y <= 1.9d-44) then
tmp = t_0
else if (y <= 2d+91) then
tmp = t_1
else
tmp = 3.0d0 * (y * sqrt(x))
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = -Math.sqrt((x * 9.0));
double t_1 = Math.sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -5e+52) {
tmp = Math.sqrt(x) * (y * 3.0);
} else if (y <= -3.7e-184) {
tmp = t_1;
} else if (y <= -4.4e-238) {
tmp = t_0;
} else if (y <= 1.3e-147) {
tmp = t_1;
} else if (y <= 1.9e-44) {
tmp = t_0;
} else if (y <= 2e+91) {
tmp = t_1;
} else {
tmp = 3.0 * (y * Math.sqrt(x));
}
return tmp;
}
def code(x, y): t_0 = -math.sqrt((x * 9.0)) t_1 = math.sqrt((0.1111111111111111 / x)) tmp = 0 if y <= -5e+52: tmp = math.sqrt(x) * (y * 3.0) elif y <= -3.7e-184: tmp = t_1 elif y <= -4.4e-238: tmp = t_0 elif y <= 1.3e-147: tmp = t_1 elif y <= 1.9e-44: tmp = t_0 elif y <= 2e+91: tmp = t_1 else: tmp = 3.0 * (y * math.sqrt(x)) return tmp
function code(x, y) t_0 = Float64(-sqrt(Float64(x * 9.0))) t_1 = sqrt(Float64(0.1111111111111111 / x)) tmp = 0.0 if (y <= -5e+52) tmp = Float64(sqrt(x) * Float64(y * 3.0)); elseif (y <= -3.7e-184) tmp = t_1; elseif (y <= -4.4e-238) tmp = t_0; elseif (y <= 1.3e-147) tmp = t_1; elseif (y <= 1.9e-44) tmp = t_0; elseif (y <= 2e+91) tmp = t_1; else tmp = Float64(3.0 * Float64(y * sqrt(x))); end return tmp end
function tmp_2 = code(x, y) t_0 = -sqrt((x * 9.0)); t_1 = sqrt((0.1111111111111111 / x)); tmp = 0.0; if (y <= -5e+52) tmp = sqrt(x) * (y * 3.0); elseif (y <= -3.7e-184) tmp = t_1; elseif (y <= -4.4e-238) tmp = t_0; elseif (y <= 1.3e-147) tmp = t_1; elseif (y <= 1.9e-44) tmp = t_0; elseif (y <= 2e+91) tmp = t_1; else tmp = 3.0 * (y * sqrt(x)); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = (-N[Sqrt[N[(x * 9.0), $MachinePrecision]], $MachinePrecision])}, Block[{t$95$1 = N[Sqrt[N[(0.1111111111111111 / x), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y, -5e+52], N[(N[Sqrt[x], $MachinePrecision] * N[(y * 3.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -3.7e-184], t$95$1, If[LessEqual[y, -4.4e-238], t$95$0, If[LessEqual[y, 1.3e-147], t$95$1, If[LessEqual[y, 1.9e-44], t$95$0, If[LessEqual[y, 2e+91], t$95$1, N[(3.0 * N[(y * N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -\sqrt{x \cdot 9}\\
t_1 := \sqrt{\frac{0.1111111111111111}{x}}\\
\mathbf{if}\;y \leq -5 \cdot 10^{+52}:\\
\;\;\;\;\sqrt{x} \cdot \left(y \cdot 3\right)\\
\mathbf{elif}\;y \leq -3.7 \cdot 10^{-184}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -4.4 \cdot 10^{-238}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 1.3 \cdot 10^{-147}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{-44}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+91}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;3 \cdot \left(y \cdot \sqrt{x}\right)\\
\end{array}
\end{array}
if y < -5e52Initial program 99.5%
*-commutative99.5%
associate-*l*99.5%
associate--l+99.5%
distribute-lft-in99.5%
fma-define99.5%
sub-neg99.5%
+-commutative99.5%
distribute-lft-in99.5%
metadata-eval99.5%
metadata-eval99.5%
*-commutative99.5%
associate-/r*99.5%
associate-*r/99.5%
metadata-eval99.5%
metadata-eval99.5%
Simplified99.5%
Taylor expanded in y around inf 79.4%
*-commutative79.4%
associate-*l*79.6%
*-commutative79.6%
Simplified79.6%
if -5e52 < y < -3.6999999999999999e-184 or -4.39999999999999982e-238 < y < 1.2999999999999999e-147 or 1.9e-44 < y < 2.00000000000000016e91Initial program 99.3%
*-commutative99.3%
associate-*l*99.3%
associate--l+99.3%
distribute-lft-in99.3%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.3%
metadata-eval99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.3%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
add-sqr-sqrt68.7%
sqrt-unprod68.5%
swap-sqr34.7%
add-sqr-sqrt34.7%
pow234.7%
+-commutative34.7%
Applied egg-rr34.7%
Taylor expanded in x around 0 61.0%
if -3.6999999999999999e-184 < y < -4.39999999999999982e-238 or 1.2999999999999999e-147 < y < 1.9e-44Initial program 99.5%
+-commutative99.5%
associate--l+99.5%
*-commutative99.5%
associate-/r*99.4%
metadata-eval99.4%
sub-neg99.4%
metadata-eval99.4%
Simplified99.4%
*-commutative99.4%
metadata-eval99.4%
sqrt-prod99.7%
pow1/299.7%
Applied egg-rr99.7%
unpow1/299.7%
Simplified99.7%
Taylor expanded in y around 0 99.7%
sub-neg99.7%
associate-*r/99.7%
metadata-eval99.7%
metadata-eval99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in x around inf 70.9%
if 2.00000000000000016e91 < y Initial program 99.3%
*-commutative99.3%
associate-*l*99.4%
associate--l+99.4%
distribute-lft-in99.4%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.3%
metadata-eval99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.4%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in y around inf 85.5%
Final simplification70.7%
(FPCore (x y)
:precision binary64
(let* ((t_0 (sqrt (* x 9.0)))
(t_1 (- t_0))
(t_2 (* t_0 y))
(t_3 (sqrt (/ 0.1111111111111111 x))))
(if (<= y -1.72e+56)
t_2
(if (<= y -2.3e-180)
t_3
(if (<= y -8e-240)
t_1
(if (<= y 1.2e-147)
t_3
(if (<= y 9.5e-45) t_1 (if (<= y 2.9e+91) t_3 t_2))))))))
double code(double x, double y) {
double t_0 = sqrt((x * 9.0));
double t_1 = -t_0;
double t_2 = t_0 * y;
double t_3 = sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -1.72e+56) {
tmp = t_2;
} else if (y <= -2.3e-180) {
tmp = t_3;
} else if (y <= -8e-240) {
tmp = t_1;
} else if (y <= 1.2e-147) {
tmp = t_3;
} else if (y <= 9.5e-45) {
tmp = t_1;
} else if (y <= 2.9e+91) {
tmp = t_3;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = sqrt((x * 9.0d0))
t_1 = -t_0
t_2 = t_0 * y
t_3 = sqrt((0.1111111111111111d0 / x))
if (y <= (-1.72d+56)) then
tmp = t_2
else if (y <= (-2.3d-180)) then
tmp = t_3
else if (y <= (-8d-240)) then
tmp = t_1
else if (y <= 1.2d-147) then
tmp = t_3
else if (y <= 9.5d-45) then
tmp = t_1
else if (y <= 2.9d+91) then
tmp = t_3
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.sqrt((x * 9.0));
double t_1 = -t_0;
double t_2 = t_0 * y;
double t_3 = Math.sqrt((0.1111111111111111 / x));
double tmp;
if (y <= -1.72e+56) {
tmp = t_2;
} else if (y <= -2.3e-180) {
tmp = t_3;
} else if (y <= -8e-240) {
tmp = t_1;
} else if (y <= 1.2e-147) {
tmp = t_3;
} else if (y <= 9.5e-45) {
tmp = t_1;
} else if (y <= 2.9e+91) {
tmp = t_3;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y): t_0 = math.sqrt((x * 9.0)) t_1 = -t_0 t_2 = t_0 * y t_3 = math.sqrt((0.1111111111111111 / x)) tmp = 0 if y <= -1.72e+56: tmp = t_2 elif y <= -2.3e-180: tmp = t_3 elif y <= -8e-240: tmp = t_1 elif y <= 1.2e-147: tmp = t_3 elif y <= 9.5e-45: tmp = t_1 elif y <= 2.9e+91: tmp = t_3 else: tmp = t_2 return tmp
function code(x, y) t_0 = sqrt(Float64(x * 9.0)) t_1 = Float64(-t_0) t_2 = Float64(t_0 * y) t_3 = sqrt(Float64(0.1111111111111111 / x)) tmp = 0.0 if (y <= -1.72e+56) tmp = t_2; elseif (y <= -2.3e-180) tmp = t_3; elseif (y <= -8e-240) tmp = t_1; elseif (y <= 1.2e-147) tmp = t_3; elseif (y <= 9.5e-45) tmp = t_1; elseif (y <= 2.9e+91) tmp = t_3; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y) t_0 = sqrt((x * 9.0)); t_1 = -t_0; t_2 = t_0 * y; t_3 = sqrt((0.1111111111111111 / x)); tmp = 0.0; if (y <= -1.72e+56) tmp = t_2; elseif (y <= -2.3e-180) tmp = t_3; elseif (y <= -8e-240) tmp = t_1; elseif (y <= 1.2e-147) tmp = t_3; elseif (y <= 9.5e-45) tmp = t_1; elseif (y <= 2.9e+91) tmp = t_3; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[Sqrt[N[(x * 9.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = (-t$95$0)}, Block[{t$95$2 = N[(t$95$0 * y), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(0.1111111111111111 / x), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y, -1.72e+56], t$95$2, If[LessEqual[y, -2.3e-180], t$95$3, If[LessEqual[y, -8e-240], t$95$1, If[LessEqual[y, 1.2e-147], t$95$3, If[LessEqual[y, 9.5e-45], t$95$1, If[LessEqual[y, 2.9e+91], t$95$3, t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{x \cdot 9}\\
t_1 := -t\_0\\
t_2 := t\_0 \cdot y\\
t_3 := \sqrt{\frac{0.1111111111111111}{x}}\\
\mathbf{if}\;y \leq -1.72 \cdot 10^{+56}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -2.3 \cdot 10^{-180}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;y \leq -8 \cdot 10^{-240}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{-147}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;y \leq 9.5 \cdot 10^{-45}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.9 \cdot 10^{+91}:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -1.72e56 or 2.90000000000000014e91 < y Initial program 99.4%
+-commutative99.4%
associate--l+99.4%
*-commutative99.4%
associate-/r*99.4%
metadata-eval99.4%
sub-neg99.4%
metadata-eval99.4%
Simplified99.4%
*-commutative99.4%
metadata-eval99.4%
sqrt-prod99.6%
pow1/299.6%
Applied egg-rr99.6%
unpow1/299.6%
Simplified99.6%
Taylor expanded in y around inf 82.3%
if -1.72e56 < y < -2.29999999999999996e-180 or -7.9999999999999998e-240 < y < 1.19999999999999999e-147 or 9.5000000000000002e-45 < y < 2.90000000000000014e91Initial program 99.3%
*-commutative99.3%
associate-*l*99.3%
associate--l+99.3%
distribute-lft-in99.3%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.3%
metadata-eval99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.3%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
add-sqr-sqrt68.7%
sqrt-unprod68.5%
swap-sqr34.7%
add-sqr-sqrt34.7%
pow234.7%
+-commutative34.7%
Applied egg-rr34.7%
Taylor expanded in x around 0 61.0%
if -2.29999999999999996e-180 < y < -7.9999999999999998e-240 or 1.19999999999999999e-147 < y < 9.5000000000000002e-45Initial program 99.5%
+-commutative99.5%
associate--l+99.5%
*-commutative99.5%
associate-/r*99.4%
metadata-eval99.4%
sub-neg99.4%
metadata-eval99.4%
Simplified99.4%
*-commutative99.4%
metadata-eval99.4%
sqrt-prod99.7%
pow1/299.7%
Applied egg-rr99.7%
unpow1/299.7%
Simplified99.7%
Taylor expanded in y around 0 99.7%
sub-neg99.7%
associate-*r/99.7%
metadata-eval99.7%
metadata-eval99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in x around inf 70.9%
Final simplification70.8%
(FPCore (x y) :precision binary64 (if (or (<= y -4.7e+56) (not (<= y 2e+91))) (* (sqrt (* x 9.0)) y) (* (sqrt x) (+ (/ 0.3333333333333333 x) -3.0))))
double code(double x, double y) {
double tmp;
if ((y <= -4.7e+56) || !(y <= 2e+91)) {
tmp = sqrt((x * 9.0)) * y;
} else {
tmp = sqrt(x) * ((0.3333333333333333 / x) + -3.0);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-4.7d+56)) .or. (.not. (y <= 2d+91))) then
tmp = sqrt((x * 9.0d0)) * y
else
tmp = sqrt(x) * ((0.3333333333333333d0 / x) + (-3.0d0))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -4.7e+56) || !(y <= 2e+91)) {
tmp = Math.sqrt((x * 9.0)) * y;
} else {
tmp = Math.sqrt(x) * ((0.3333333333333333 / x) + -3.0);
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -4.7e+56) or not (y <= 2e+91): tmp = math.sqrt((x * 9.0)) * y else: tmp = math.sqrt(x) * ((0.3333333333333333 / x) + -3.0) return tmp
function code(x, y) tmp = 0.0 if ((y <= -4.7e+56) || !(y <= 2e+91)) tmp = Float64(sqrt(Float64(x * 9.0)) * y); else tmp = Float64(sqrt(x) * Float64(Float64(0.3333333333333333 / x) + -3.0)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -4.7e+56) || ~((y <= 2e+91))) tmp = sqrt((x * 9.0)) * y; else tmp = sqrt(x) * ((0.3333333333333333 / x) + -3.0); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -4.7e+56], N[Not[LessEqual[y, 2e+91]], $MachinePrecision]], N[(N[Sqrt[N[(x * 9.0), $MachinePrecision]], $MachinePrecision] * y), $MachinePrecision], N[(N[Sqrt[x], $MachinePrecision] * N[(N[(0.3333333333333333 / x), $MachinePrecision] + -3.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -4.7 \cdot 10^{+56} \lor \neg \left(y \leq 2 \cdot 10^{+91}\right):\\
\;\;\;\;\sqrt{x \cdot 9} \cdot y\\
\mathbf{else}:\\
\;\;\;\;\sqrt{x} \cdot \left(\frac{0.3333333333333333}{x} + -3\right)\\
\end{array}
\end{array}
if y < -4.7e56 or 2.00000000000000016e91 < y Initial program 99.4%
+-commutative99.4%
associate--l+99.4%
*-commutative99.4%
associate-/r*99.4%
metadata-eval99.4%
sub-neg99.4%
metadata-eval99.4%
Simplified99.4%
*-commutative99.4%
metadata-eval99.4%
sqrt-prod99.6%
pow1/299.6%
Applied egg-rr99.6%
unpow1/299.6%
Simplified99.6%
Taylor expanded in y around inf 82.3%
if -4.7e56 < y < 2.00000000000000016e91Initial program 99.4%
*-commutative99.4%
associate-*l*99.3%
associate--l+99.3%
distribute-lft-in99.3%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.4%
metadata-eval99.4%
metadata-eval99.4%
*-commutative99.4%
associate-/r*99.3%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in y around 0 92.0%
sub-neg92.0%
metadata-eval92.0%
associate-*r/92.0%
metadata-eval92.0%
+-commutative92.0%
Simplified92.0%
Final simplification88.0%
(FPCore (x y)
:precision binary64
(let* ((t_0 (sqrt (* x 9.0))))
(if (<= y -3.1e+54)
(* t_0 y)
(if (<= y 1.65e+91)
(* (sqrt x) (+ (/ 0.3333333333333333 x) -3.0))
(* t_0 (+ y -1.0))))))
double code(double x, double y) {
double t_0 = sqrt((x * 9.0));
double tmp;
if (y <= -3.1e+54) {
tmp = t_0 * y;
} else if (y <= 1.65e+91) {
tmp = sqrt(x) * ((0.3333333333333333 / x) + -3.0);
} else {
tmp = t_0 * (y + -1.0);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = sqrt((x * 9.0d0))
if (y <= (-3.1d+54)) then
tmp = t_0 * y
else if (y <= 1.65d+91) then
tmp = sqrt(x) * ((0.3333333333333333d0 / x) + (-3.0d0))
else
tmp = t_0 * (y + (-1.0d0))
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = Math.sqrt((x * 9.0));
double tmp;
if (y <= -3.1e+54) {
tmp = t_0 * y;
} else if (y <= 1.65e+91) {
tmp = Math.sqrt(x) * ((0.3333333333333333 / x) + -3.0);
} else {
tmp = t_0 * (y + -1.0);
}
return tmp;
}
def code(x, y): t_0 = math.sqrt((x * 9.0)) tmp = 0 if y <= -3.1e+54: tmp = t_0 * y elif y <= 1.65e+91: tmp = math.sqrt(x) * ((0.3333333333333333 / x) + -3.0) else: tmp = t_0 * (y + -1.0) return tmp
function code(x, y) t_0 = sqrt(Float64(x * 9.0)) tmp = 0.0 if (y <= -3.1e+54) tmp = Float64(t_0 * y); elseif (y <= 1.65e+91) tmp = Float64(sqrt(x) * Float64(Float64(0.3333333333333333 / x) + -3.0)); else tmp = Float64(t_0 * Float64(y + -1.0)); end return tmp end
function tmp_2 = code(x, y) t_0 = sqrt((x * 9.0)); tmp = 0.0; if (y <= -3.1e+54) tmp = t_0 * y; elseif (y <= 1.65e+91) tmp = sqrt(x) * ((0.3333333333333333 / x) + -3.0); else tmp = t_0 * (y + -1.0); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[Sqrt[N[(x * 9.0), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y, -3.1e+54], N[(t$95$0 * y), $MachinePrecision], If[LessEqual[y, 1.65e+91], N[(N[Sqrt[x], $MachinePrecision] * N[(N[(0.3333333333333333 / x), $MachinePrecision] + -3.0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{x \cdot 9}\\
\mathbf{if}\;y \leq -3.1 \cdot 10^{+54}:\\
\;\;\;\;t\_0 \cdot y\\
\mathbf{elif}\;y \leq 1.65 \cdot 10^{+91}:\\
\;\;\;\;\sqrt{x} \cdot \left(\frac{0.3333333333333333}{x} + -3\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0 \cdot \left(y + -1\right)\\
\end{array}
\end{array}
if y < -3.0999999999999999e54Initial program 99.5%
+-commutative99.5%
associate--l+99.5%
*-commutative99.5%
associate-/r*99.4%
metadata-eval99.4%
sub-neg99.4%
metadata-eval99.4%
Simplified99.4%
*-commutative99.4%
metadata-eval99.4%
sqrt-prod99.7%
pow1/299.7%
Applied egg-rr99.7%
unpow1/299.7%
Simplified99.7%
Taylor expanded in y around inf 79.7%
if -3.0999999999999999e54 < y < 1.65000000000000009e91Initial program 99.4%
*-commutative99.4%
associate-*l*99.3%
associate--l+99.3%
distribute-lft-in99.3%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.4%
metadata-eval99.4%
metadata-eval99.4%
*-commutative99.4%
associate-/r*99.3%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
Taylor expanded in y around 0 92.0%
sub-neg92.0%
metadata-eval92.0%
associate-*r/92.0%
metadata-eval92.0%
+-commutative92.0%
Simplified92.0%
if 1.65000000000000009e91 < y Initial program 99.3%
+-commutative99.3%
associate--l+99.3%
*-commutative99.3%
associate-/r*99.3%
metadata-eval99.3%
sub-neg99.3%
metadata-eval99.3%
Simplified99.3%
*-commutative99.3%
metadata-eval99.3%
sqrt-prod99.5%
pow1/299.5%
Applied egg-rr99.5%
unpow1/299.5%
Simplified99.5%
Taylor expanded in x around inf 85.5%
Final simplification88.0%
(FPCore (x y) :precision binary64 (* (sqrt x) (* (+ (/ 0.1111111111111111 x) (+ y -1.0)) 3.0)))
double code(double x, double y) {
return sqrt(x) * (((0.1111111111111111 / x) + (y + -1.0)) * 3.0);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt(x) * (((0.1111111111111111d0 / x) + (y + (-1.0d0))) * 3.0d0)
end function
public static double code(double x, double y) {
return Math.sqrt(x) * (((0.1111111111111111 / x) + (y + -1.0)) * 3.0);
}
def code(x, y): return math.sqrt(x) * (((0.1111111111111111 / x) + (y + -1.0)) * 3.0)
function code(x, y) return Float64(sqrt(x) * Float64(Float64(Float64(0.1111111111111111 / x) + Float64(y + -1.0)) * 3.0)) end
function tmp = code(x, y) tmp = sqrt(x) * (((0.1111111111111111 / x) + (y + -1.0)) * 3.0); end
code[x_, y_] := N[(N[Sqrt[x], $MachinePrecision] * N[(N[(N[(0.1111111111111111 / x), $MachinePrecision] + N[(y + -1.0), $MachinePrecision]), $MachinePrecision] * 3.0), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{x} \cdot \left(\left(\frac{0.1111111111111111}{x} + \left(y + -1\right)\right) \cdot 3\right)
\end{array}
Initial program 99.4%
+-commutative99.4%
associate--l+99.4%
*-commutative99.4%
associate-/r*99.3%
metadata-eval99.3%
sub-neg99.3%
metadata-eval99.3%
Simplified99.3%
*-commutative99.3%
metadata-eval99.3%
sqrt-prod99.5%
pow1/299.5%
Applied egg-rr99.5%
unpow1/299.5%
Simplified99.5%
Taylor expanded in y around 0 99.3%
associate-*r*99.3%
associate-*r*99.3%
distribute-lft-out99.3%
sub-neg99.3%
associate-*r/99.3%
metadata-eval99.3%
metadata-eval99.3%
associate-+l+99.3%
+-commutative99.3%
*-commutative99.3%
associate-+r+99.3%
associate-*l*99.4%
Simplified99.4%
Final simplification99.4%
(FPCore (x y) :precision binary64 (* (sqrt x) (+ (+ (/ 0.3333333333333333 x) -3.0) (* y 3.0))))
double code(double x, double y) {
return sqrt(x) * (((0.3333333333333333 / x) + -3.0) + (y * 3.0));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt(x) * (((0.3333333333333333d0 / x) + (-3.0d0)) + (y * 3.0d0))
end function
public static double code(double x, double y) {
return Math.sqrt(x) * (((0.3333333333333333 / x) + -3.0) + (y * 3.0));
}
def code(x, y): return math.sqrt(x) * (((0.3333333333333333 / x) + -3.0) + (y * 3.0))
function code(x, y) return Float64(sqrt(x) * Float64(Float64(Float64(0.3333333333333333 / x) + -3.0) + Float64(y * 3.0))) end
function tmp = code(x, y) tmp = sqrt(x) * (((0.3333333333333333 / x) + -3.0) + (y * 3.0)); end
code[x_, y_] := N[(N[Sqrt[x], $MachinePrecision] * N[(N[(N[(0.3333333333333333 / x), $MachinePrecision] + -3.0), $MachinePrecision] + N[(y * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sqrt{x} \cdot \left(\left(\frac{0.3333333333333333}{x} + -3\right) + y \cdot 3\right)
\end{array}
Initial program 99.4%
*-commutative99.4%
associate-*l*99.4%
associate--l+99.4%
distribute-lft-in99.4%
fma-define99.4%
sub-neg99.4%
+-commutative99.4%
distribute-lft-in99.4%
metadata-eval99.4%
metadata-eval99.4%
*-commutative99.4%
associate-/r*99.4%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
fma-undefine99.4%
+-commutative99.4%
+-commutative99.4%
Applied egg-rr99.4%
Final simplification99.4%
(FPCore (x y) :precision binary64 (if (<= x 0.112) (sqrt (/ 0.1111111111111111 x)) (* (sqrt x) -3.0)))
double code(double x, double y) {
double tmp;
if (x <= 0.112) {
tmp = sqrt((0.1111111111111111 / x));
} else {
tmp = sqrt(x) * -3.0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= 0.112d0) then
tmp = sqrt((0.1111111111111111d0 / x))
else
tmp = sqrt(x) * (-3.0d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= 0.112) {
tmp = Math.sqrt((0.1111111111111111 / x));
} else {
tmp = Math.sqrt(x) * -3.0;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= 0.112: tmp = math.sqrt((0.1111111111111111 / x)) else: tmp = math.sqrt(x) * -3.0 return tmp
function code(x, y) tmp = 0.0 if (x <= 0.112) tmp = sqrt(Float64(0.1111111111111111 / x)); else tmp = Float64(sqrt(x) * -3.0); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= 0.112) tmp = sqrt((0.1111111111111111 / x)); else tmp = sqrt(x) * -3.0; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, 0.112], N[Sqrt[N[(0.1111111111111111 / x), $MachinePrecision]], $MachinePrecision], N[(N[Sqrt[x], $MachinePrecision] * -3.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq 0.112:\\
\;\;\;\;\sqrt{\frac{0.1111111111111111}{x}}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{x} \cdot -3\\
\end{array}
\end{array}
if x < 0.112000000000000002Initial program 99.3%
*-commutative99.3%
associate-*l*99.2%
associate--l+99.2%
distribute-lft-in99.2%
fma-define99.3%
sub-neg99.3%
+-commutative99.3%
distribute-lft-in99.3%
metadata-eval99.3%
metadata-eval99.3%
*-commutative99.3%
associate-/r*99.3%
associate-*r/99.3%
metadata-eval99.3%
metadata-eval99.3%
Simplified99.3%
add-sqr-sqrt86.0%
sqrt-unprod81.8%
swap-sqr32.2%
add-sqr-sqrt32.2%
pow232.2%
+-commutative32.2%
Applied egg-rr32.2%
Taylor expanded in x around 0 70.2%
if 0.112000000000000002 < x Initial program 99.5%
+-commutative99.5%
associate--l+99.5%
*-commutative99.5%
associate-/r*99.5%
metadata-eval99.5%
sub-neg99.5%
metadata-eval99.5%
Simplified99.5%
*-commutative99.5%
metadata-eval99.5%
sqrt-prod99.7%
pow1/299.7%
Applied egg-rr99.7%
unpow1/299.7%
Simplified99.7%
Taylor expanded in x around inf 97.9%
Taylor expanded in y around 0 48.9%
*-commutative48.9%
Simplified48.9%
Final simplification60.9%
(FPCore (x y) :precision binary64 (sqrt (/ 0.1111111111111111 x)))
double code(double x, double y) {
return sqrt((0.1111111111111111 / x));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = sqrt((0.1111111111111111d0 / x))
end function
public static double code(double x, double y) {
return Math.sqrt((0.1111111111111111 / x));
}
def code(x, y): return math.sqrt((0.1111111111111111 / x))
function code(x, y) return sqrt(Float64(0.1111111111111111 / x)) end
function tmp = code(x, y) tmp = sqrt((0.1111111111111111 / x)); end
code[x_, y_] := N[Sqrt[N[(0.1111111111111111 / x), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sqrt{\frac{0.1111111111111111}{x}}
\end{array}
Initial program 99.4%
*-commutative99.4%
associate-*l*99.4%
associate--l+99.4%
distribute-lft-in99.4%
fma-define99.4%
sub-neg99.4%
+-commutative99.4%
distribute-lft-in99.4%
metadata-eval99.4%
metadata-eval99.4%
*-commutative99.4%
associate-/r*99.4%
associate-*r/99.4%
metadata-eval99.4%
metadata-eval99.4%
Simplified99.4%
add-sqr-sqrt58.4%
sqrt-unprod51.0%
swap-sqr23.1%
add-sqr-sqrt23.1%
pow223.1%
+-commutative23.1%
Applied egg-rr23.1%
Taylor expanded in x around 0 40.3%
Final simplification40.3%
(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 2024095
(FPCore (x y)
:name "Numeric.SpecFunctions:incompleteGamma from math-functions-0.1.5.2, B"
:precision binary64
:alt
(* 3.0 (+ (* y (sqrt x)) (* (- (/ 1.0 (* x 9.0)) 1.0) (sqrt x))))
(* (* 3.0 (sqrt x)) (- (+ y (/ 1.0 (* x 9.0))) 1.0)))