
(FPCore (a b) :precision binary64 (* (* (/ PI 2.0) (/ 1.0 (- (* b b) (* a a)))) (- (/ 1.0 a) (/ 1.0 b))))
double code(double a, double b) {
return ((((double) M_PI) / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b));
}
public static double code(double a, double b) {
return ((Math.PI / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b));
}
def code(a, b): return ((math.pi / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b))
function code(a, b) return Float64(Float64(Float64(pi / 2.0) * Float64(1.0 / Float64(Float64(b * b) - Float64(a * a)))) * Float64(Float64(1.0 / a) - Float64(1.0 / b))) end
function tmp = code(a, b) tmp = ((pi / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b)); end
code[a_, b_] := N[(N[(N[(Pi / 2.0), $MachinePrecision] * N[(1.0 / N[(N[(b * b), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 / a), $MachinePrecision] - N[(1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\frac{\pi}{2} \cdot \frac{1}{b \cdot b - a \cdot a}\right) \cdot \left(\frac{1}{a} - \frac{1}{b}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 8 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b) :precision binary64 (* (* (/ PI 2.0) (/ 1.0 (- (* b b) (* a a)))) (- (/ 1.0 a) (/ 1.0 b))))
double code(double a, double b) {
return ((((double) M_PI) / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b));
}
public static double code(double a, double b) {
return ((Math.PI / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b));
}
def code(a, b): return ((math.pi / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b))
function code(a, b) return Float64(Float64(Float64(pi / 2.0) * Float64(1.0 / Float64(Float64(b * b) - Float64(a * a)))) * Float64(Float64(1.0 / a) - Float64(1.0 / b))) end
function tmp = code(a, b) tmp = ((pi / 2.0) * (1.0 / ((b * b) - (a * a)))) * ((1.0 / a) - (1.0 / b)); end
code[a_, b_] := N[(N[(N[(Pi / 2.0), $MachinePrecision] * N[(1.0 / N[(N[(b * b), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 / a), $MachinePrecision] - N[(1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\frac{\pi}{2} \cdot \frac{1}{b \cdot b - a \cdot a}\right) \cdot \left(\frac{1}{a} - \frac{1}{b}\right)
\end{array}
(FPCore (a b) :precision binary64 (/ (/ (+ (/ -0.5 b) (/ 0.5 a)) (+ b a)) (/ (- b a) PI)))
double code(double a, double b) {
return (((-0.5 / b) + (0.5 / a)) / (b + a)) / ((b - a) / ((double) M_PI));
}
public static double code(double a, double b) {
return (((-0.5 / b) + (0.5 / a)) / (b + a)) / ((b - a) / Math.PI);
}
def code(a, b): return (((-0.5 / b) + (0.5 / a)) / (b + a)) / ((b - a) / math.pi)
function code(a, b) return Float64(Float64(Float64(Float64(-0.5 / b) + Float64(0.5 / a)) / Float64(b + a)) / Float64(Float64(b - a) / pi)) end
function tmp = code(a, b) tmp = (((-0.5 / b) + (0.5 / a)) / (b + a)) / ((b - a) / pi); end
code[a_, b_] := N[(N[(N[(N[(-0.5 / b), $MachinePrecision] + N[(0.5 / a), $MachinePrecision]), $MachinePrecision] / N[(b + a), $MachinePrecision]), $MachinePrecision] / N[(N[(b - a), $MachinePrecision] / Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\frac{-0.5}{b} + \frac{0.5}{a}}{b + a}}{\frac{b - a}{\pi}}
\end{array}
Initial program 73.1%
times-frac73.2%
*-commutative73.2%
times-frac73.2%
difference-of-squares84.9%
associate-/r*86.0%
metadata-eval86.0%
sub-neg86.0%
distribute-neg-frac86.0%
metadata-eval86.0%
Simplified86.0%
clear-num84.9%
inv-pow84.9%
Applied egg-rr84.9%
unpow-184.9%
Applied egg-rr84.9%
distribute-lft-in78.2%
associate-*l/78.2%
metadata-eval78.2%
associate-/r/78.2%
associate-*l/78.2%
metadata-eval78.2%
associate-/r/78.2%
Applied egg-rr78.2%
distribute-lft-in84.8%
associate-*l/84.8%
*-commutative84.8%
associate-/r*99.3%
+-commutative99.3%
distribute-lft-in99.3%
associate-*r/99.6%
metadata-eval99.6%
associate-*r/99.6%
metadata-eval99.6%
+-commutative99.6%
Simplified99.6%
Final simplification99.6%
(FPCore (a b)
:precision binary64
(let* ((t_0 (* (/ 1.0 a) (* 0.5 (/ (/ PI (+ b a)) (- b a))))))
(if (<= b 3.35e-243)
(/ PI (/ (* a (* b a)) 0.5))
(if (<= b 1.3e-175)
t_0
(if (<= b 1.25e-111)
(* (/ PI a) (/ (/ 0.5 b) a))
(if (<= b 4e+141)
t_0
(/ (* (/ PI b) (+ (/ 1.0 a) (/ -1.0 b))) (* b 2.0))))))))
double code(double a, double b) {
double t_0 = (1.0 / a) * (0.5 * ((((double) M_PI) / (b + a)) / (b - a)));
double tmp;
if (b <= 3.35e-243) {
tmp = ((double) M_PI) / ((a * (b * a)) / 0.5);
} else if (b <= 1.3e-175) {
tmp = t_0;
} else if (b <= 1.25e-111) {
tmp = (((double) M_PI) / a) * ((0.5 / b) / a);
} else if (b <= 4e+141) {
tmp = t_0;
} else {
tmp = ((((double) M_PI) / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0);
}
return tmp;
}
public static double code(double a, double b) {
double t_0 = (1.0 / a) * (0.5 * ((Math.PI / (b + a)) / (b - a)));
double tmp;
if (b <= 3.35e-243) {
tmp = Math.PI / ((a * (b * a)) / 0.5);
} else if (b <= 1.3e-175) {
tmp = t_0;
} else if (b <= 1.25e-111) {
tmp = (Math.PI / a) * ((0.5 / b) / a);
} else if (b <= 4e+141) {
tmp = t_0;
} else {
tmp = ((Math.PI / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0);
}
return tmp;
}
def code(a, b): t_0 = (1.0 / a) * (0.5 * ((math.pi / (b + a)) / (b - a))) tmp = 0 if b <= 3.35e-243: tmp = math.pi / ((a * (b * a)) / 0.5) elif b <= 1.3e-175: tmp = t_0 elif b <= 1.25e-111: tmp = (math.pi / a) * ((0.5 / b) / a) elif b <= 4e+141: tmp = t_0 else: tmp = ((math.pi / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0) return tmp
function code(a, b) t_0 = Float64(Float64(1.0 / a) * Float64(0.5 * Float64(Float64(pi / Float64(b + a)) / Float64(b - a)))) tmp = 0.0 if (b <= 3.35e-243) tmp = Float64(pi / Float64(Float64(a * Float64(b * a)) / 0.5)); elseif (b <= 1.3e-175) tmp = t_0; elseif (b <= 1.25e-111) tmp = Float64(Float64(pi / a) * Float64(Float64(0.5 / b) / a)); elseif (b <= 4e+141) tmp = t_0; else tmp = Float64(Float64(Float64(pi / b) * Float64(Float64(1.0 / a) + Float64(-1.0 / b))) / Float64(b * 2.0)); end return tmp end
function tmp_2 = code(a, b) t_0 = (1.0 / a) * (0.5 * ((pi / (b + a)) / (b - a))); tmp = 0.0; if (b <= 3.35e-243) tmp = pi / ((a * (b * a)) / 0.5); elseif (b <= 1.3e-175) tmp = t_0; elseif (b <= 1.25e-111) tmp = (pi / a) * ((0.5 / b) / a); elseif (b <= 4e+141) tmp = t_0; else tmp = ((pi / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0); end tmp_2 = tmp; end
code[a_, b_] := Block[{t$95$0 = N[(N[(1.0 / a), $MachinePrecision] * N[(0.5 * N[(N[(Pi / N[(b + a), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, 3.35e-243], N[(Pi / N[(N[(a * N[(b * a), $MachinePrecision]), $MachinePrecision] / 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.3e-175], t$95$0, If[LessEqual[b, 1.25e-111], N[(N[(Pi / a), $MachinePrecision] * N[(N[(0.5 / b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4e+141], t$95$0, N[(N[(N[(Pi / b), $MachinePrecision] * N[(N[(1.0 / a), $MachinePrecision] + N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(b * 2.0), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{a} \cdot \left(0.5 \cdot \frac{\frac{\pi}{b + a}}{b - a}\right)\\
\mathbf{if}\;b \leq 3.35 \cdot 10^{-243}:\\
\;\;\;\;\frac{\pi}{\frac{a \cdot \left(b \cdot a\right)}{0.5}}\\
\mathbf{elif}\;b \leq 1.3 \cdot 10^{-175}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;b \leq 1.25 \cdot 10^{-111}:\\
\;\;\;\;\frac{\pi}{a} \cdot \frac{\frac{0.5}{b}}{a}\\
\mathbf{elif}\;b \leq 4 \cdot 10^{+141}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\pi}{b} \cdot \left(\frac{1}{a} + \frac{-1}{b}\right)}{b \cdot 2}\\
\end{array}
\end{array}
if b < 3.35000000000000004e-243Initial program 71.9%
times-frac71.9%
*-commutative71.9%
times-frac71.9%
difference-of-squares86.0%
associate-/r*87.4%
metadata-eval87.4%
sub-neg87.4%
distribute-neg-frac87.4%
metadata-eval87.4%
Simplified87.4%
add-cube-cbrt87.1%
pow387.1%
Applied egg-rr87.1%
Taylor expanded in b around 0 59.5%
associate-*r/59.5%
*-commutative59.5%
unpow259.5%
associate-/l*59.5%
associate-*l*68.2%
Simplified68.2%
if 3.35000000000000004e-243 < b < 1.3e-175 or 1.2500000000000001e-111 < b < 4.00000000000000007e141Initial program 87.4%
times-frac87.4%
*-commutative87.4%
times-frac87.4%
difference-of-squares92.2%
associate-/r*92.3%
metadata-eval92.3%
sub-neg92.3%
distribute-neg-frac92.3%
metadata-eval92.3%
Simplified92.3%
Taylor expanded in a around 0 77.9%
if 1.3e-175 < b < 1.2500000000000001e-111Initial program 86.7%
times-frac86.6%
*-commutative86.6%
times-frac86.6%
difference-of-squares86.6%
associate-/r*86.7%
metadata-eval86.7%
sub-neg86.7%
distribute-neg-frac86.7%
metadata-eval86.7%
Simplified86.7%
add-cube-cbrt85.7%
pow285.7%
Applied egg-rr85.7%
Taylor expanded in b around 0 79.3%
associate-*r/79.3%
*-commutative79.3%
times-frac79.4%
unpow279.4%
Simplified79.4%
associate-*l/79.4%
Applied egg-rr79.4%
times-frac92.6%
Simplified92.6%
if 4.00000000000000007e141 < b Initial program 42.9%
Taylor expanded in b around inf 62.9%
unpow262.9%
associate-/r*65.7%
Simplified65.7%
frac-times65.7%
Applied egg-rr65.7%
associate-*r/65.7%
*-rgt-identity65.7%
Simplified65.7%
associate-*l/99.5%
*-commutative99.5%
Applied egg-rr99.5%
Final simplification75.6%
(FPCore (a b)
:precision binary64
(if (<= b 3.3e-243)
(/ PI (/ (* a (* b a)) 0.5))
(if (<= b 2e+131)
(* (+ (/ -0.5 b) (/ 0.5 a)) (/ PI (- (* b b) (* a a))))
(/ (* (/ PI b) (+ (/ 1.0 a) (/ -1.0 b))) (* b 2.0)))))
double code(double a, double b) {
double tmp;
if (b <= 3.3e-243) {
tmp = ((double) M_PI) / ((a * (b * a)) / 0.5);
} else if (b <= 2e+131) {
tmp = ((-0.5 / b) + (0.5 / a)) * (((double) M_PI) / ((b * b) - (a * a)));
} else {
tmp = ((((double) M_PI) / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0);
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (b <= 3.3e-243) {
tmp = Math.PI / ((a * (b * a)) / 0.5);
} else if (b <= 2e+131) {
tmp = ((-0.5 / b) + (0.5 / a)) * (Math.PI / ((b * b) - (a * a)));
} else {
tmp = ((Math.PI / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0);
}
return tmp;
}
def code(a, b): tmp = 0 if b <= 3.3e-243: tmp = math.pi / ((a * (b * a)) / 0.5) elif b <= 2e+131: tmp = ((-0.5 / b) + (0.5 / a)) * (math.pi / ((b * b) - (a * a))) else: tmp = ((math.pi / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0) return tmp
function code(a, b) tmp = 0.0 if (b <= 3.3e-243) tmp = Float64(pi / Float64(Float64(a * Float64(b * a)) / 0.5)); elseif (b <= 2e+131) tmp = Float64(Float64(Float64(-0.5 / b) + Float64(0.5 / a)) * Float64(pi / Float64(Float64(b * b) - Float64(a * a)))); else tmp = Float64(Float64(Float64(pi / b) * Float64(Float64(1.0 / a) + Float64(-1.0 / b))) / Float64(b * 2.0)); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (b <= 3.3e-243) tmp = pi / ((a * (b * a)) / 0.5); elseif (b <= 2e+131) tmp = ((-0.5 / b) + (0.5 / a)) * (pi / ((b * b) - (a * a))); else tmp = ((pi / b) * ((1.0 / a) + (-1.0 / b))) / (b * 2.0); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[b, 3.3e-243], N[(Pi / N[(N[(a * N[(b * a), $MachinePrecision]), $MachinePrecision] / 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2e+131], N[(N[(N[(-0.5 / b), $MachinePrecision] + N[(0.5 / a), $MachinePrecision]), $MachinePrecision] * N[(Pi / N[(N[(b * b), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(Pi / b), $MachinePrecision] * N[(N[(1.0 / a), $MachinePrecision] + N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(b * 2.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 3.3 \cdot 10^{-243}:\\
\;\;\;\;\frac{\pi}{\frac{a \cdot \left(b \cdot a\right)}{0.5}}\\
\mathbf{elif}\;b \leq 2 \cdot 10^{+131}:\\
\;\;\;\;\left(\frac{-0.5}{b} + \frac{0.5}{a}\right) \cdot \frac{\pi}{b \cdot b - a \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\pi}{b} \cdot \left(\frac{1}{a} + \frac{-1}{b}\right)}{b \cdot 2}\\
\end{array}
\end{array}
if b < 3.30000000000000013e-243Initial program 71.9%
times-frac71.9%
*-commutative71.9%
times-frac71.9%
difference-of-squares86.0%
associate-/r*87.4%
metadata-eval87.4%
sub-neg87.4%
distribute-neg-frac87.4%
metadata-eval87.4%
Simplified87.4%
add-cube-cbrt87.1%
pow387.1%
Applied egg-rr87.1%
Taylor expanded in b around 0 59.5%
associate-*r/59.5%
*-commutative59.5%
unpow259.5%
associate-/l*59.5%
associate-*l*68.2%
Simplified68.2%
if 3.30000000000000013e-243 < b < 1.9999999999999998e131Initial program 86.8%
times-frac86.8%
*-commutative86.8%
times-frac86.8%
difference-of-squares90.9%
associate-/r*90.9%
metadata-eval90.9%
sub-neg90.9%
distribute-neg-frac90.9%
metadata-eval90.9%
Simplified90.9%
distribute-lft-in82.8%
associate-/l/82.7%
associate-/l/82.8%
Applied egg-rr82.8%
distribute-lft-out90.9%
associate-*r*90.9%
associate-*l/90.8%
*-commutative90.8%
difference-of-squares86.7%
associate-*l/86.8%
distribute-lft-in86.8%
associate-*r/86.8%
metadata-eval86.8%
associate-*r/86.8%
metadata-eval86.8%
Simplified86.8%
if 1.9999999999999998e131 < b Initial program 48.0%
Taylor expanded in b around inf 66.2%
unpow266.2%
associate-/r*68.6%
Simplified68.6%
frac-times68.8%
Applied egg-rr68.8%
associate-*r/68.8%
*-rgt-identity68.8%
Simplified68.8%
associate-*l/99.5%
*-commutative99.5%
Applied egg-rr99.5%
Final simplification77.6%
(FPCore (a b) :precision binary64 (if (<= a -2.3e-31) (* (/ PI a) (/ (/ 0.5 b) a)) (* 0.5 (/ PI (* a (* b b))))))
double code(double a, double b) {
double tmp;
if (a <= -2.3e-31) {
tmp = (((double) M_PI) / a) * ((0.5 / b) / a);
} else {
tmp = 0.5 * (((double) M_PI) / (a * (b * b)));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -2.3e-31) {
tmp = (Math.PI / a) * ((0.5 / b) / a);
} else {
tmp = 0.5 * (Math.PI / (a * (b * b)));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -2.3e-31: tmp = (math.pi / a) * ((0.5 / b) / a) else: tmp = 0.5 * (math.pi / (a * (b * b))) return tmp
function code(a, b) tmp = 0.0 if (a <= -2.3e-31) tmp = Float64(Float64(pi / a) * Float64(Float64(0.5 / b) / a)); else tmp = Float64(0.5 * Float64(pi / Float64(a * Float64(b * b)))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -2.3e-31) tmp = (pi / a) * ((0.5 / b) / a); else tmp = 0.5 * (pi / (a * (b * b))); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -2.3e-31], N[(N[(Pi / a), $MachinePrecision] * N[(N[(0.5 / b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi / N[(a * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.3 \cdot 10^{-31}:\\
\;\;\;\;\frac{\pi}{a} \cdot \frac{\frac{0.5}{b}}{a}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{\pi}{a \cdot \left(b \cdot b\right)}\\
\end{array}
\end{array}
if a < -2.2999999999999998e-31Initial program 68.7%
times-frac68.8%
*-commutative68.8%
times-frac68.8%
difference-of-squares82.0%
associate-/r*83.0%
metadata-eval83.0%
sub-neg83.0%
distribute-neg-frac83.0%
metadata-eval83.0%
Simplified83.0%
add-cube-cbrt82.6%
pow282.6%
Applied egg-rr82.6%
Taylor expanded in b around 0 69.7%
associate-*r/69.7%
*-commutative69.7%
times-frac68.6%
unpow268.6%
Simplified68.6%
associate-*l/67.3%
Applied egg-rr67.3%
times-frac84.8%
Simplified84.8%
if -2.2999999999999998e-31 < a Initial program 74.7%
*-commutative74.7%
associate-/r/74.7%
associate-*l/74.7%
*-commutative74.7%
associate-/r/74.7%
times-frac74.7%
Simplified74.7%
Taylor expanded in b around inf 60.3%
unpow260.3%
Simplified60.3%
Final simplification66.8%
(FPCore (a b) :precision binary64 (if (<= a -4.1e-33) (* (/ PI a) (/ (/ 0.5 b) a)) (* 0.5 (/ (/ PI a) (* b b)))))
double code(double a, double b) {
double tmp;
if (a <= -4.1e-33) {
tmp = (((double) M_PI) / a) * ((0.5 / b) / a);
} else {
tmp = 0.5 * ((((double) M_PI) / a) / (b * b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -4.1e-33) {
tmp = (Math.PI / a) * ((0.5 / b) / a);
} else {
tmp = 0.5 * ((Math.PI / a) / (b * b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -4.1e-33: tmp = (math.pi / a) * ((0.5 / b) / a) else: tmp = 0.5 * ((math.pi / a) / (b * b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -4.1e-33) tmp = Float64(Float64(pi / a) * Float64(Float64(0.5 / b) / a)); else tmp = Float64(0.5 * Float64(Float64(pi / a) / Float64(b * b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -4.1e-33) tmp = (pi / a) * ((0.5 / b) / a); else tmp = 0.5 * ((pi / a) / (b * b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -4.1e-33], N[(N[(Pi / a), $MachinePrecision] * N[(N[(0.5 / b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(N[(Pi / a), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4.1 \cdot 10^{-33}:\\
\;\;\;\;\frac{\pi}{a} \cdot \frac{\frac{0.5}{b}}{a}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{\frac{\pi}{a}}{b \cdot b}\\
\end{array}
\end{array}
if a < -4.1e-33Initial program 68.7%
times-frac68.8%
*-commutative68.8%
times-frac68.8%
difference-of-squares82.0%
associate-/r*83.0%
metadata-eval83.0%
sub-neg83.0%
distribute-neg-frac83.0%
metadata-eval83.0%
Simplified83.0%
add-cube-cbrt82.6%
pow282.6%
Applied egg-rr82.6%
Taylor expanded in b around 0 69.7%
associate-*r/69.7%
*-commutative69.7%
times-frac68.6%
unpow268.6%
Simplified68.6%
associate-*l/67.3%
Applied egg-rr67.3%
times-frac84.8%
Simplified84.8%
if -4.1e-33 < a Initial program 74.7%
*-commutative74.7%
associate-/r/74.7%
associate-*l/74.7%
*-commutative74.7%
associate-/r/74.7%
times-frac74.7%
Simplified74.7%
Taylor expanded in b around inf 60.3%
unpow260.3%
Simplified60.3%
div-inv60.2%
Applied egg-rr60.2%
Taylor expanded in a around 0 60.3%
associate-/r*60.3%
unpow260.3%
Simplified60.3%
Final simplification66.8%
(FPCore (a b) :precision binary64 (if (<= a -4.1e-25) (/ PI (/ (* a (* b a)) 0.5)) (* 0.5 (/ (/ PI a) (* b b)))))
double code(double a, double b) {
double tmp;
if (a <= -4.1e-25) {
tmp = ((double) M_PI) / ((a * (b * a)) / 0.5);
} else {
tmp = 0.5 * ((((double) M_PI) / a) / (b * b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -4.1e-25) {
tmp = Math.PI / ((a * (b * a)) / 0.5);
} else {
tmp = 0.5 * ((Math.PI / a) / (b * b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -4.1e-25: tmp = math.pi / ((a * (b * a)) / 0.5) else: tmp = 0.5 * ((math.pi / a) / (b * b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -4.1e-25) tmp = Float64(pi / Float64(Float64(a * Float64(b * a)) / 0.5)); else tmp = Float64(0.5 * Float64(Float64(pi / a) / Float64(b * b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -4.1e-25) tmp = pi / ((a * (b * a)) / 0.5); else tmp = 0.5 * ((pi / a) / (b * b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -4.1e-25], N[(Pi / N[(N[(a * N[(b * a), $MachinePrecision]), $MachinePrecision] / 0.5), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(N[(Pi / a), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4.1 \cdot 10^{-25}:\\
\;\;\;\;\frac{\pi}{\frac{a \cdot \left(b \cdot a\right)}{0.5}}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{\frac{\pi}{a}}{b \cdot b}\\
\end{array}
\end{array}
if a < -4.09999999999999987e-25Initial program 68.2%
times-frac68.3%
*-commutative68.3%
times-frac68.3%
difference-of-squares81.7%
associate-/r*82.7%
metadata-eval82.7%
sub-neg82.7%
distribute-neg-frac82.7%
metadata-eval82.7%
Simplified82.7%
add-cube-cbrt82.3%
pow382.3%
Applied egg-rr82.3%
Taylor expanded in b around 0 70.7%
associate-*r/70.7%
*-commutative70.7%
unpow270.7%
associate-/l*70.7%
associate-*l*87.2%
Simplified87.2%
if -4.09999999999999987e-25 < a Initial program 74.8%
*-commutative74.8%
associate-/r/74.8%
associate-*l/74.8%
*-commutative74.8%
associate-/r/74.8%
times-frac74.8%
Simplified74.9%
Taylor expanded in b around inf 60.5%
unpow260.5%
Simplified60.5%
div-inv60.4%
Applied egg-rr60.4%
Taylor expanded in a around 0 60.5%
associate-/r*60.5%
unpow260.5%
Simplified60.5%
Final simplification67.5%
(FPCore (a b) :precision binary64 (* (/ PI a) (/ 0.5 (* b a))))
double code(double a, double b) {
return (((double) M_PI) / a) * (0.5 / (b * a));
}
public static double code(double a, double b) {
return (Math.PI / a) * (0.5 / (b * a));
}
def code(a, b): return (math.pi / a) * (0.5 / (b * a))
function code(a, b) return Float64(Float64(pi / a) * Float64(0.5 / Float64(b * a))) end
function tmp = code(a, b) tmp = (pi / a) * (0.5 / (b * a)); end
code[a_, b_] := N[(N[(Pi / a), $MachinePrecision] * N[(0.5 / N[(b * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\pi}{a} \cdot \frac{0.5}{b \cdot a}
\end{array}
Initial program 73.1%
times-frac73.2%
*-commutative73.2%
times-frac73.2%
difference-of-squares84.9%
associate-/r*86.0%
metadata-eval86.0%
sub-neg86.0%
distribute-neg-frac86.0%
metadata-eval86.0%
Simplified86.0%
add-cube-cbrt85.6%
pow285.6%
Applied egg-rr85.6%
Taylor expanded in b around 0 54.0%
associate-*r/54.0%
*-commutative54.0%
times-frac53.7%
unpow253.7%
Simplified53.7%
associate-*l/53.4%
Applied egg-rr53.4%
times-frac61.3%
Simplified61.3%
Taylor expanded in b around 0 61.3%
Final simplification61.3%
(FPCore (a b) :precision binary64 (* (/ PI a) (/ (/ 0.5 b) a)))
double code(double a, double b) {
return (((double) M_PI) / a) * ((0.5 / b) / a);
}
public static double code(double a, double b) {
return (Math.PI / a) * ((0.5 / b) / a);
}
def code(a, b): return (math.pi / a) * ((0.5 / b) / a)
function code(a, b) return Float64(Float64(pi / a) * Float64(Float64(0.5 / b) / a)) end
function tmp = code(a, b) tmp = (pi / a) * ((0.5 / b) / a); end
code[a_, b_] := N[(N[(Pi / a), $MachinePrecision] * N[(N[(0.5 / b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\pi}{a} \cdot \frac{\frac{0.5}{b}}{a}
\end{array}
Initial program 73.1%
times-frac73.2%
*-commutative73.2%
times-frac73.2%
difference-of-squares84.9%
associate-/r*86.0%
metadata-eval86.0%
sub-neg86.0%
distribute-neg-frac86.0%
metadata-eval86.0%
Simplified86.0%
add-cube-cbrt85.6%
pow285.6%
Applied egg-rr85.6%
Taylor expanded in b around 0 54.0%
associate-*r/54.0%
*-commutative54.0%
times-frac53.7%
unpow253.7%
Simplified53.7%
associate-*l/53.4%
Applied egg-rr53.4%
times-frac61.3%
Simplified61.3%
Final simplification61.3%
herbie shell --seed 2023230
(FPCore (a b)
:name "NMSE Section 6.1 mentioned, B"
:precision binary64
(* (* (/ PI 2.0) (/ 1.0 (- (* b b) (* a a)))) (- (/ 1.0 a) (/ 1.0 b))))