
(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 17 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 (* (/ (/ (- (/ PI a) (/ PI b)) (+ a b)) (- b a)) 0.5))
double code(double a, double b) {
return ((((((double) M_PI) / a) - (((double) M_PI) / b)) / (a + b)) / (b - a)) * 0.5;
}
public static double code(double a, double b) {
return ((((Math.PI / a) - (Math.PI / b)) / (a + b)) / (b - a)) * 0.5;
}
def code(a, b): return ((((math.pi / a) - (math.pi / b)) / (a + b)) / (b - a)) * 0.5
function code(a, b) return Float64(Float64(Float64(Float64(Float64(pi / a) - Float64(pi / b)) / Float64(a + b)) / Float64(b - a)) * 0.5) end
function tmp = code(a, b) tmp = ((((pi / a) - (pi / b)) / (a + b)) / (b - a)) * 0.5; end
code[a_, b_] := N[(N[(N[(N[(N[(Pi / a), $MachinePrecision] - N[(Pi / b), $MachinePrecision]), $MachinePrecision] / N[(a + b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision] * 0.5), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\frac{\pi}{a} - \frac{\pi}{b}}{a + b}}{b - a} \cdot 0.5
\end{array}
Initial program 79.6%
*-commutative79.6%
associate-/r/79.6%
associate-*l/79.7%
*-commutative79.7%
associate-/r/79.7%
times-frac79.7%
Simplified79.7%
clear-num79.7%
inv-pow79.7%
Applied egg-rr79.7%
unpow-179.7%
fma-def79.7%
+-commutative79.7%
associate-*r/79.7%
*-commutative79.7%
associate-*r/79.7%
mul-1-neg79.7%
unsub-neg79.7%
Simplified79.7%
div-sub68.0%
Applied egg-rr68.0%
div-sub79.7%
difference-of-squares89.0%
*-commutative89.0%
associate-/l*99.6%
Simplified99.6%
expm1-log1p-u77.8%
expm1-udef51.8%
associate-/r/51.8%
+-commutative51.8%
Applied egg-rr51.8%
expm1-def77.9%
expm1-log1p99.6%
associate-*l/99.7%
*-lft-identity99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (a b)
:precision binary64
(if (<= a -5e+129)
(* 0.5 (/ 1.0 (* a (/ a (/ PI b)))))
(if (<= a -4.4e-255)
(* (* 0.5 (/ (/ PI (+ a b)) (- b a))) (+ (/ 1.0 a) (/ -1.0 b)))
(* 0.5 (* PI (/ (/ 1.0 (* a b)) b))))))
double code(double a, double b) {
double tmp;
if (a <= -5e+129) {
tmp = 0.5 * (1.0 / (a * (a / (((double) M_PI) / b))));
} else if (a <= -4.4e-255) {
tmp = (0.5 * ((((double) M_PI) / (a + b)) / (b - a))) * ((1.0 / a) + (-1.0 / b));
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -5e+129) {
tmp = 0.5 * (1.0 / (a * (a / (Math.PI / b))));
} else if (a <= -4.4e-255) {
tmp = (0.5 * ((Math.PI / (a + b)) / (b - a))) * ((1.0 / a) + (-1.0 / b));
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -5e+129: tmp = 0.5 * (1.0 / (a * (a / (math.pi / b)))) elif a <= -4.4e-255: tmp = (0.5 * ((math.pi / (a + b)) / (b - a))) * ((1.0 / a) + (-1.0 / b)) else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -5e+129) tmp = Float64(0.5 * Float64(1.0 / Float64(a * Float64(a / Float64(pi / b))))); elseif (a <= -4.4e-255) tmp = Float64(Float64(0.5 * Float64(Float64(pi / Float64(a + b)) / Float64(b - a))) * Float64(Float64(1.0 / a) + Float64(-1.0 / b))); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -5e+129) tmp = 0.5 * (1.0 / (a * (a / (pi / b)))); elseif (a <= -4.4e-255) tmp = (0.5 * ((pi / (a + b)) / (b - a))) * ((1.0 / a) + (-1.0 / b)); else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -5e+129], N[(0.5 * N[(1.0 / N[(a * N[(a / N[(Pi / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -4.4e-255], N[(N[(0.5 * N[(N[(Pi / N[(a + b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 / a), $MachinePrecision] + N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5 \cdot 10^{+129}:\\
\;\;\;\;0.5 \cdot \frac{1}{a \cdot \frac{a}{\frac{\pi}{b}}}\\
\mathbf{elif}\;a \leq -4.4 \cdot 10^{-255}:\\
\;\;\;\;\left(0.5 \cdot \frac{\frac{\pi}{a + b}}{b - a}\right) \cdot \left(\frac{1}{a} + \frac{-1}{b}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -5.0000000000000003e129Initial program 51.6%
*-commutative51.6%
associate-/r/51.6%
associate-*l/51.6%
*-commutative51.6%
associate-/r/51.6%
times-frac51.6%
Simplified51.6%
clear-num51.6%
inv-pow51.6%
Applied egg-rr51.6%
unpow-151.6%
fma-def51.6%
+-commutative51.6%
associate-*r/51.6%
*-commutative51.6%
associate-*r/51.6%
mul-1-neg51.6%
unsub-neg51.6%
Simplified51.6%
Taylor expanded in b around 0 76.6%
unpow276.6%
associate-/l*76.6%
*-lft-identity76.6%
times-frac99.9%
/-rgt-identity99.9%
Simplified99.9%
if -5.0000000000000003e129 < a < -4.3999999999999998e-255Initial program 89.3%
times-frac89.5%
*-commutative89.5%
times-frac89.5%
difference-of-squares93.0%
associate-/r*93.6%
metadata-eval93.6%
sub-neg93.6%
distribute-neg-frac93.6%
metadata-eval93.6%
Simplified93.6%
if -4.3999999999999998e-255 < a Initial program 81.0%
*-commutative81.0%
associate-/r/81.0%
associate-*l/81.0%
*-commutative81.0%
associate-/r/81.0%
times-frac81.0%
Simplified81.0%
Taylor expanded in b around inf 66.2%
unpow266.2%
Simplified66.2%
div-inv66.1%
Applied egg-rr66.1%
inv-pow66.1%
associate-*r*73.1%
unpow-prod-down72.6%
inv-pow72.6%
Applied egg-rr72.6%
associate-*r/72.6%
*-rgt-identity72.6%
unpow-172.6%
Simplified72.6%
Final simplification83.4%
(FPCore (a b)
:precision binary64
(if (<= a -1e+99)
(* 0.5 (/ 1.0 (* a (/ a (/ PI b)))))
(if (<= a -2.8e-162)
(* (/ PI (- (* b b) (* a a))) (+ (/ 0.5 a) (/ -0.5 b)))
(* 0.5 (* PI (/ (/ 1.0 (* a b)) b))))))
double code(double a, double b) {
double tmp;
if (a <= -1e+99) {
tmp = 0.5 * (1.0 / (a * (a / (((double) M_PI) / b))));
} else if (a <= -2.8e-162) {
tmp = (((double) M_PI) / ((b * b) - (a * a))) * ((0.5 / a) + (-0.5 / b));
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -1e+99) {
tmp = 0.5 * (1.0 / (a * (a / (Math.PI / b))));
} else if (a <= -2.8e-162) {
tmp = (Math.PI / ((b * b) - (a * a))) * ((0.5 / a) + (-0.5 / b));
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -1e+99: tmp = 0.5 * (1.0 / (a * (a / (math.pi / b)))) elif a <= -2.8e-162: tmp = (math.pi / ((b * b) - (a * a))) * ((0.5 / a) + (-0.5 / b)) else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -1e+99) tmp = Float64(0.5 * Float64(1.0 / Float64(a * Float64(a / Float64(pi / b))))); elseif (a <= -2.8e-162) tmp = Float64(Float64(pi / Float64(Float64(b * b) - Float64(a * a))) * Float64(Float64(0.5 / a) + Float64(-0.5 / b))); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -1e+99) tmp = 0.5 * (1.0 / (a * (a / (pi / b)))); elseif (a <= -2.8e-162) tmp = (pi / ((b * b) - (a * a))) * ((0.5 / a) + (-0.5 / b)); else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -1e+99], N[(0.5 * N[(1.0 / N[(a * N[(a / N[(Pi / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -2.8e-162], N[(N[(Pi / N[(N[(b * b), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(0.5 / a), $MachinePrecision] + N[(-0.5 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1 \cdot 10^{+99}:\\
\;\;\;\;0.5 \cdot \frac{1}{a \cdot \frac{a}{\frac{\pi}{b}}}\\
\mathbf{elif}\;a \leq -2.8 \cdot 10^{-162}:\\
\;\;\;\;\frac{\pi}{b \cdot b - a \cdot a} \cdot \left(\frac{0.5}{a} + \frac{-0.5}{b}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -9.9999999999999997e98Initial program 57.5%
*-commutative57.5%
associate-/r/57.5%
associate-*l/57.5%
*-commutative57.5%
associate-/r/57.5%
times-frac57.5%
Simplified57.5%
clear-num57.5%
inv-pow57.5%
Applied egg-rr57.5%
unpow-157.5%
fma-def57.5%
+-commutative57.5%
associate-*r/57.5%
*-commutative57.5%
associate-*r/57.5%
mul-1-neg57.5%
unsub-neg57.5%
Simplified57.5%
Taylor expanded in b around 0 79.4%
unpow279.4%
associate-/l*79.4%
*-lft-identity79.4%
times-frac99.9%
/-rgt-identity99.9%
Simplified99.9%
if -9.9999999999999997e98 < a < -2.80000000000000022e-162Initial program 94.8%
times-frac95.0%
*-commutative95.0%
times-frac95.0%
difference-of-squares95.0%
associate-/r*95.7%
metadata-eval95.7%
sub-neg95.7%
distribute-neg-frac95.7%
metadata-eval95.7%
Simplified95.7%
distribute-lft-in94.1%
associate-/l/93.3%
associate-/l/93.4%
Applied egg-rr93.4%
distribute-lft-out95.0%
associate-*r*95.0%
associate-*l/94.9%
*-commutative94.9%
difference-of-squares94.9%
associate-*l/95.0%
distribute-lft-in95.0%
associate-*r/95.0%
metadata-eval95.0%
associate-*r/95.0%
metadata-eval95.0%
Simplified95.0%
if -2.80000000000000022e-162 < a Initial program 79.4%
*-commutative79.4%
associate-/r/79.4%
associate-*l/79.5%
*-commutative79.5%
associate-/r/79.5%
times-frac79.5%
Simplified79.4%
Taylor expanded in b around inf 68.3%
unpow268.3%
Simplified68.3%
div-inv68.3%
Applied egg-rr68.3%
inv-pow68.3%
associate-*r*76.2%
unpow-prod-down75.8%
inv-pow75.8%
Applied egg-rr75.8%
associate-*r/75.8%
*-rgt-identity75.8%
unpow-175.8%
Simplified75.8%
Final simplification84.3%
(FPCore (a b)
:precision binary64
(if (<= a -1.4e-23)
(* (/ (/ PI (* a b)) (- b a)) (- 0.5))
(if (<= a -7.2e-59)
(/ (/ (/ PI (- b a)) (+ a b)) (/ a 0.5))
(if (<= a -7.5e-132)
(* 0.5 (/ (- (/ PI b)) (- (* b b) (* a a))))
(* 0.5 (* PI (/ (/ 1.0 (* a b)) b)))))))
double code(double a, double b) {
double tmp;
if (a <= -1.4e-23) {
tmp = ((((double) M_PI) / (a * b)) / (b - a)) * -0.5;
} else if (a <= -7.2e-59) {
tmp = ((((double) M_PI) / (b - a)) / (a + b)) / (a / 0.5);
} else if (a <= -7.5e-132) {
tmp = 0.5 * (-(((double) M_PI) / b) / ((b * b) - (a * a)));
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -1.4e-23) {
tmp = ((Math.PI / (a * b)) / (b - a)) * -0.5;
} else if (a <= -7.2e-59) {
tmp = ((Math.PI / (b - a)) / (a + b)) / (a / 0.5);
} else if (a <= -7.5e-132) {
tmp = 0.5 * (-(Math.PI / b) / ((b * b) - (a * a)));
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -1.4e-23: tmp = ((math.pi / (a * b)) / (b - a)) * -0.5 elif a <= -7.2e-59: tmp = ((math.pi / (b - a)) / (a + b)) / (a / 0.5) elif a <= -7.5e-132: tmp = 0.5 * (-(math.pi / b) / ((b * b) - (a * a))) else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -1.4e-23) tmp = Float64(Float64(Float64(pi / Float64(a * b)) / Float64(b - a)) * Float64(-0.5)); elseif (a <= -7.2e-59) tmp = Float64(Float64(Float64(pi / Float64(b - a)) / Float64(a + b)) / Float64(a / 0.5)); elseif (a <= -7.5e-132) tmp = Float64(0.5 * Float64(Float64(-Float64(pi / b)) / Float64(Float64(b * b) - Float64(a * a)))); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -1.4e-23) tmp = ((pi / (a * b)) / (b - a)) * -0.5; elseif (a <= -7.2e-59) tmp = ((pi / (b - a)) / (a + b)) / (a / 0.5); elseif (a <= -7.5e-132) tmp = 0.5 * (-(pi / b) / ((b * b) - (a * a))); else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -1.4e-23], N[(N[(N[(Pi / N[(a * b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision] * (-0.5)), $MachinePrecision], If[LessEqual[a, -7.2e-59], N[(N[(N[(Pi / N[(b - a), $MachinePrecision]), $MachinePrecision] / N[(a + b), $MachinePrecision]), $MachinePrecision] / N[(a / 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -7.5e-132], N[(0.5 * N[((-N[(Pi / b), $MachinePrecision]) / N[(N[(b * b), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.4 \cdot 10^{-23}:\\
\;\;\;\;\frac{\frac{\pi}{a \cdot b}}{b - a} \cdot \left(-0.5\right)\\
\mathbf{elif}\;a \leq -7.2 \cdot 10^{-59}:\\
\;\;\;\;\frac{\frac{\frac{\pi}{b - a}}{a + b}}{\frac{a}{0.5}}\\
\mathbf{elif}\;a \leq -7.5 \cdot 10^{-132}:\\
\;\;\;\;0.5 \cdot \frac{-\frac{\pi}{b}}{b \cdot b - a \cdot a}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -1.3999999999999999e-23Initial program 75.8%
*-commutative75.8%
associate-/r/75.8%
associate-*l/75.9%
*-commutative75.9%
associate-/r/75.9%
times-frac75.9%
Simplified76.0%
clear-num75.9%
inv-pow75.9%
Applied egg-rr75.9%
unpow-175.9%
fma-def75.9%
+-commutative75.9%
associate-*r/75.9%
*-commutative75.9%
associate-*r/75.9%
mul-1-neg75.9%
unsub-neg75.9%
Simplified75.9%
div-sub69.1%
Applied egg-rr69.1%
div-sub75.9%
difference-of-squares88.3%
*-commutative88.3%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u89.6%
expm1-udef62.1%
associate-/r/62.1%
+-commutative62.1%
Applied egg-rr62.1%
expm1-def89.5%
expm1-log1p99.6%
associate-*l/99.8%
*-lft-identity99.8%
Simplified99.8%
Taylor expanded in a around inf 92.9%
associate-*r/92.9%
neg-mul-192.9%
Simplified92.9%
if -1.3999999999999999e-23 < a < -7.20000000000000001e-59Initial program 98.9%
times-frac98.9%
*-commutative98.9%
times-frac98.9%
difference-of-squares98.9%
associate-/r*99.1%
metadata-eval99.1%
sub-neg99.1%
distribute-neg-frac99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in a around 0 83.5%
expm1-log1p-u60.4%
expm1-udef12.0%
un-div-inv12.0%
associate-/l/12.0%
+-commutative12.0%
Applied egg-rr12.0%
expm1-def60.1%
expm1-log1p83.4%
associate-/l*83.4%
associate-/r*83.6%
Simplified83.6%
if -7.20000000000000001e-59 < a < -7.49999999999999989e-132Initial program 85.2%
*-commutative85.2%
associate-/r/85.0%
associate-*l/85.1%
*-commutative85.1%
associate-/r/85.1%
times-frac85.1%
Simplified85.2%
Taylor expanded in b around 0 55.4%
associate-*r/55.4%
mul-1-neg55.4%
Simplified55.4%
if -7.49999999999999989e-132 < a Initial program 79.7%
*-commutative79.7%
associate-/r/79.7%
associate-*l/79.8%
*-commutative79.8%
associate-/r/79.8%
times-frac79.8%
Simplified79.7%
Taylor expanded in b around inf 67.9%
unpow267.9%
Simplified67.9%
div-inv67.8%
Applied egg-rr67.8%
inv-pow67.8%
associate-*r*76.0%
unpow-prod-down75.6%
inv-pow75.6%
Applied egg-rr75.6%
associate-*r/75.6%
*-rgt-identity75.6%
unpow-175.6%
Simplified75.6%
Final simplification79.8%
(FPCore (a b)
:precision binary64
(if (<= a -5.8e-33)
(* (/ (/ PI (* a b)) (- b a)) (- 0.5))
(if (<= a -3.4e-59)
(* (* 0.5 (/ PI (* b b))) (/ (- b a) (* a b)))
(if (<= a -1.02e-131)
(* 0.5 (/ (- (/ PI b)) (- (* b b) (* a a))))
(* 0.5 (* PI (/ (/ 1.0 (* a b)) b)))))))
double code(double a, double b) {
double tmp;
if (a <= -5.8e-33) {
tmp = ((((double) M_PI) / (a * b)) / (b - a)) * -0.5;
} else if (a <= -3.4e-59) {
tmp = (0.5 * (((double) M_PI) / (b * b))) * ((b - a) / (a * b));
} else if (a <= -1.02e-131) {
tmp = 0.5 * (-(((double) M_PI) / b) / ((b * b) - (a * a)));
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -5.8e-33) {
tmp = ((Math.PI / (a * b)) / (b - a)) * -0.5;
} else if (a <= -3.4e-59) {
tmp = (0.5 * (Math.PI / (b * b))) * ((b - a) / (a * b));
} else if (a <= -1.02e-131) {
tmp = 0.5 * (-(Math.PI / b) / ((b * b) - (a * a)));
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -5.8e-33: tmp = ((math.pi / (a * b)) / (b - a)) * -0.5 elif a <= -3.4e-59: tmp = (0.5 * (math.pi / (b * b))) * ((b - a) / (a * b)) elif a <= -1.02e-131: tmp = 0.5 * (-(math.pi / b) / ((b * b) - (a * a))) else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -5.8e-33) tmp = Float64(Float64(Float64(pi / Float64(a * b)) / Float64(b - a)) * Float64(-0.5)); elseif (a <= -3.4e-59) tmp = Float64(Float64(0.5 * Float64(pi / Float64(b * b))) * Float64(Float64(b - a) / Float64(a * b))); elseif (a <= -1.02e-131) tmp = Float64(0.5 * Float64(Float64(-Float64(pi / b)) / Float64(Float64(b * b) - Float64(a * a)))); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -5.8e-33) tmp = ((pi / (a * b)) / (b - a)) * -0.5; elseif (a <= -3.4e-59) tmp = (0.5 * (pi / (b * b))) * ((b - a) / (a * b)); elseif (a <= -1.02e-131) tmp = 0.5 * (-(pi / b) / ((b * b) - (a * a))); else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -5.8e-33], N[(N[(N[(Pi / N[(a * b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision] * (-0.5)), $MachinePrecision], If[LessEqual[a, -3.4e-59], N[(N[(0.5 * N[(Pi / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(b - a), $MachinePrecision] / N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.02e-131], N[(0.5 * N[((-N[(Pi / b), $MachinePrecision]) / N[(N[(b * b), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -5.8 \cdot 10^{-33}:\\
\;\;\;\;\frac{\frac{\pi}{a \cdot b}}{b - a} \cdot \left(-0.5\right)\\
\mathbf{elif}\;a \leq -3.4 \cdot 10^{-59}:\\
\;\;\;\;\left(0.5 \cdot \frac{\pi}{b \cdot b}\right) \cdot \frac{b - a}{a \cdot b}\\
\mathbf{elif}\;a \leq -1.02 \cdot 10^{-131}:\\
\;\;\;\;0.5 \cdot \frac{-\frac{\pi}{b}}{b \cdot b - a \cdot a}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -5.80000000000000005e-33Initial program 76.4%
*-commutative76.4%
associate-/r/76.4%
associate-*l/76.5%
*-commutative76.5%
associate-/r/76.5%
times-frac76.5%
Simplified76.6%
clear-num76.6%
inv-pow76.6%
Applied egg-rr76.6%
unpow-176.6%
fma-def76.5%
+-commutative76.5%
associate-*r/76.6%
*-commutative76.6%
associate-*r/76.6%
mul-1-neg76.6%
unsub-neg76.6%
Simplified76.6%
div-sub69.9%
Applied egg-rr69.9%
div-sub76.6%
difference-of-squares88.5%
*-commutative88.5%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u88.4%
expm1-udef61.6%
associate-/r/61.6%
+-commutative61.6%
Applied egg-rr61.6%
expm1-def88.3%
expm1-log1p99.6%
associate-*l/99.8%
*-lft-identity99.8%
Simplified99.8%
Taylor expanded in a around inf 91.8%
associate-*r/91.8%
neg-mul-191.8%
Simplified91.8%
if -5.80000000000000005e-33 < a < -3.40000000000000018e-59Initial program 99.0%
times-frac99.0%
*-commutative99.0%
times-frac99.0%
difference-of-squares99.0%
associate-/r*99.3%
metadata-eval99.3%
sub-neg99.3%
distribute-neg-frac99.3%
metadata-eval99.3%
Simplified99.3%
frac-add99.2%
*-un-lft-identity99.2%
Applied egg-rr99.2%
*-commutative99.2%
neg-mul-199.2%
sub-neg99.2%
Simplified99.2%
Taylor expanded in b around inf 93.1%
unpow293.1%
Simplified93.1%
if -3.40000000000000018e-59 < a < -1.02000000000000001e-131Initial program 85.2%
*-commutative85.2%
associate-/r/85.0%
associate-*l/85.1%
*-commutative85.1%
associate-/r/85.1%
times-frac85.1%
Simplified85.2%
Taylor expanded in b around 0 55.4%
associate-*r/55.4%
mul-1-neg55.4%
Simplified55.4%
if -1.02000000000000001e-131 < a Initial program 79.7%
*-commutative79.7%
associate-/r/79.7%
associate-*l/79.8%
*-commutative79.8%
associate-/r/79.8%
times-frac79.8%
Simplified79.7%
Taylor expanded in b around inf 67.9%
unpow267.9%
Simplified67.9%
div-inv67.8%
Applied egg-rr67.8%
inv-pow67.8%
associate-*r*76.0%
unpow-prod-down75.6%
inv-pow75.6%
Applied egg-rr75.6%
associate-*r/75.6%
*-rgt-identity75.6%
unpow-175.6%
Simplified75.6%
Final simplification79.9%
(FPCore (a b)
:precision binary64
(if (<= a -1.02e-26)
(* (/ (/ PI (* a b)) (- b a)) (- 0.5))
(if (<= a -8.8e-60)
(* (+ (/ 1.0 a) (/ -1.0 b)) (/ (/ PI 2.0) (* b b)))
(if (<= a -1.02e-131)
(* 0.5 (/ (- (/ PI b)) (- (* b b) (* a a))))
(* 0.5 (* PI (/ (/ 1.0 (* a b)) b)))))))
double code(double a, double b) {
double tmp;
if (a <= -1.02e-26) {
tmp = ((((double) M_PI) / (a * b)) / (b - a)) * -0.5;
} else if (a <= -8.8e-60) {
tmp = ((1.0 / a) + (-1.0 / b)) * ((((double) M_PI) / 2.0) / (b * b));
} else if (a <= -1.02e-131) {
tmp = 0.5 * (-(((double) M_PI) / b) / ((b * b) - (a * a)));
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -1.02e-26) {
tmp = ((Math.PI / (a * b)) / (b - a)) * -0.5;
} else if (a <= -8.8e-60) {
tmp = ((1.0 / a) + (-1.0 / b)) * ((Math.PI / 2.0) / (b * b));
} else if (a <= -1.02e-131) {
tmp = 0.5 * (-(Math.PI / b) / ((b * b) - (a * a)));
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -1.02e-26: tmp = ((math.pi / (a * b)) / (b - a)) * -0.5 elif a <= -8.8e-60: tmp = ((1.0 / a) + (-1.0 / b)) * ((math.pi / 2.0) / (b * b)) elif a <= -1.02e-131: tmp = 0.5 * (-(math.pi / b) / ((b * b) - (a * a))) else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -1.02e-26) tmp = Float64(Float64(Float64(pi / Float64(a * b)) / Float64(b - a)) * Float64(-0.5)); elseif (a <= -8.8e-60) tmp = Float64(Float64(Float64(1.0 / a) + Float64(-1.0 / b)) * Float64(Float64(pi / 2.0) / Float64(b * b))); elseif (a <= -1.02e-131) tmp = Float64(0.5 * Float64(Float64(-Float64(pi / b)) / Float64(Float64(b * b) - Float64(a * a)))); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -1.02e-26) tmp = ((pi / (a * b)) / (b - a)) * -0.5; elseif (a <= -8.8e-60) tmp = ((1.0 / a) + (-1.0 / b)) * ((pi / 2.0) / (b * b)); elseif (a <= -1.02e-131) tmp = 0.5 * (-(pi / b) / ((b * b) - (a * a))); else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -1.02e-26], N[(N[(N[(Pi / N[(a * b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision] * (-0.5)), $MachinePrecision], If[LessEqual[a, -8.8e-60], N[(N[(N[(1.0 / a), $MachinePrecision] + N[(-1.0 / b), $MachinePrecision]), $MachinePrecision] * N[(N[(Pi / 2.0), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.02e-131], N[(0.5 * N[((-N[(Pi / b), $MachinePrecision]) / N[(N[(b * b), $MachinePrecision] - N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.02 \cdot 10^{-26}:\\
\;\;\;\;\frac{\frac{\pi}{a \cdot b}}{b - a} \cdot \left(-0.5\right)\\
\mathbf{elif}\;a \leq -8.8 \cdot 10^{-60}:\\
\;\;\;\;\left(\frac{1}{a} + \frac{-1}{b}\right) \cdot \frac{\frac{\pi}{2}}{b \cdot b}\\
\mathbf{elif}\;a \leq -1.02 \cdot 10^{-131}:\\
\;\;\;\;0.5 \cdot \frac{-\frac{\pi}{b}}{b \cdot b - a \cdot a}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -1.02e-26Initial program 76.4%
*-commutative76.4%
associate-/r/76.4%
associate-*l/76.5%
*-commutative76.5%
associate-/r/76.5%
times-frac76.5%
Simplified76.6%
clear-num76.6%
inv-pow76.6%
Applied egg-rr76.6%
unpow-176.6%
fma-def76.5%
+-commutative76.5%
associate-*r/76.6%
*-commutative76.6%
associate-*r/76.6%
mul-1-neg76.6%
unsub-neg76.6%
Simplified76.6%
div-sub69.9%
Applied egg-rr69.9%
div-sub76.6%
difference-of-squares88.5%
*-commutative88.5%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u88.4%
expm1-udef61.6%
associate-/r/61.6%
+-commutative61.6%
Applied egg-rr61.6%
expm1-def88.3%
expm1-log1p99.6%
associate-*l/99.8%
*-lft-identity99.8%
Simplified99.8%
Taylor expanded in a around inf 91.8%
associate-*r/91.8%
neg-mul-191.8%
Simplified91.8%
if -1.02e-26 < a < -8.7999999999999995e-60Initial program 99.0%
associate-*r/99.0%
*-rgt-identity99.0%
sub-neg99.0%
distribute-neg-frac99.0%
metadata-eval99.0%
Simplified99.0%
Taylor expanded in b around inf 93.3%
unpow293.3%
Simplified93.3%
if -8.7999999999999995e-60 < a < -1.02000000000000001e-131Initial program 85.2%
*-commutative85.2%
associate-/r/85.0%
associate-*l/85.1%
*-commutative85.1%
associate-/r/85.1%
times-frac85.1%
Simplified85.2%
Taylor expanded in b around 0 55.4%
associate-*r/55.4%
mul-1-neg55.4%
Simplified55.4%
if -1.02000000000000001e-131 < a Initial program 79.7%
*-commutative79.7%
associate-/r/79.7%
associate-*l/79.8%
*-commutative79.8%
associate-/r/79.8%
times-frac79.8%
Simplified79.7%
Taylor expanded in b around inf 67.9%
unpow267.9%
Simplified67.9%
div-inv67.8%
Applied egg-rr67.8%
inv-pow67.8%
associate-*r*76.0%
unpow-prod-down75.6%
inv-pow75.6%
Applied egg-rr75.6%
associate-*r/75.6%
*-rgt-identity75.6%
unpow-175.6%
Simplified75.6%
Final simplification79.9%
(FPCore (a b)
:precision binary64
(let* ((t_0 (* (/ (/ PI (* a b)) (- b a)) (- 0.5))))
(if (<= a -1e-23)
t_0
(if (<= a -4.5e-58)
(/ (/ PI (* (+ a b) (- b a))) (/ a 0.5))
(if (<= a -1.02e-131) t_0 (* 0.5 (* PI (/ (/ 1.0 (* a b)) b))))))))
double code(double a, double b) {
double t_0 = ((((double) M_PI) / (a * b)) / (b - a)) * -0.5;
double tmp;
if (a <= -1e-23) {
tmp = t_0;
} else if (a <= -4.5e-58) {
tmp = (((double) M_PI) / ((a + b) * (b - a))) / (a / 0.5);
} else if (a <= -1.02e-131) {
tmp = t_0;
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double t_0 = ((Math.PI / (a * b)) / (b - a)) * -0.5;
double tmp;
if (a <= -1e-23) {
tmp = t_0;
} else if (a <= -4.5e-58) {
tmp = (Math.PI / ((a + b) * (b - a))) / (a / 0.5);
} else if (a <= -1.02e-131) {
tmp = t_0;
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): t_0 = ((math.pi / (a * b)) / (b - a)) * -0.5 tmp = 0 if a <= -1e-23: tmp = t_0 elif a <= -4.5e-58: tmp = (math.pi / ((a + b) * (b - a))) / (a / 0.5) elif a <= -1.02e-131: tmp = t_0 else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) t_0 = Float64(Float64(Float64(pi / Float64(a * b)) / Float64(b - a)) * Float64(-0.5)) tmp = 0.0 if (a <= -1e-23) tmp = t_0; elseif (a <= -4.5e-58) tmp = Float64(Float64(pi / Float64(Float64(a + b) * Float64(b - a))) / Float64(a / 0.5)); elseif (a <= -1.02e-131) tmp = t_0; else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) t_0 = ((pi / (a * b)) / (b - a)) * -0.5; tmp = 0.0; if (a <= -1e-23) tmp = t_0; elseif (a <= -4.5e-58) tmp = (pi / ((a + b) * (b - a))) / (a / 0.5); elseif (a <= -1.02e-131) tmp = t_0; else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := Block[{t$95$0 = N[(N[(N[(Pi / N[(a * b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision] * (-0.5)), $MachinePrecision]}, If[LessEqual[a, -1e-23], t$95$0, If[LessEqual[a, -4.5e-58], N[(N[(Pi / N[(N[(a + b), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a / 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.02e-131], t$95$0, N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{\pi}{a \cdot b}}{b - a} \cdot \left(-0.5\right)\\
\mathbf{if}\;a \leq -1 \cdot 10^{-23}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;a \leq -4.5 \cdot 10^{-58}:\\
\;\;\;\;\frac{\frac{\pi}{\left(a + b\right) \cdot \left(b - a\right)}}{\frac{a}{0.5}}\\
\mathbf{elif}\;a \leq -1.02 \cdot 10^{-131}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -9.9999999999999996e-24 or -4.5000000000000003e-58 < a < -1.02000000000000001e-131Initial program 77.2%
*-commutative77.2%
associate-/r/77.2%
associate-*l/77.3%
*-commutative77.3%
associate-/r/77.3%
times-frac77.3%
Simplified77.4%
clear-num77.3%
inv-pow77.3%
Applied egg-rr77.3%
unpow-177.3%
fma-def77.3%
+-commutative77.3%
associate-*r/77.3%
*-commutative77.3%
associate-*r/77.3%
mul-1-neg77.3%
unsub-neg77.3%
Simplified77.3%
div-sub68.0%
Applied egg-rr68.0%
div-sub77.3%
difference-of-squares87.8%
*-commutative87.8%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u83.0%
expm1-udef57.5%
associate-/r/57.5%
+-commutative57.5%
Applied egg-rr57.5%
expm1-def82.9%
expm1-log1p99.6%
associate-*l/99.7%
*-lft-identity99.7%
Simplified99.7%
Taylor expanded in a around inf 87.1%
associate-*r/87.1%
neg-mul-187.1%
Simplified87.1%
if -9.9999999999999996e-24 < a < -4.5000000000000003e-58Initial program 98.9%
times-frac98.9%
*-commutative98.9%
times-frac98.9%
difference-of-squares98.9%
associate-/r*99.1%
metadata-eval99.1%
sub-neg99.1%
distribute-neg-frac99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in a around 0 83.5%
expm1-log1p-u60.4%
expm1-udef12.0%
un-div-inv12.0%
associate-/l/12.0%
+-commutative12.0%
Applied egg-rr12.0%
expm1-def60.1%
expm1-log1p83.4%
associate-/l*83.4%
*-commutative83.4%
Simplified83.4%
if -1.02000000000000001e-131 < a Initial program 79.7%
*-commutative79.7%
associate-/r/79.7%
associate-*l/79.8%
*-commutative79.8%
associate-/r/79.8%
times-frac79.8%
Simplified79.7%
Taylor expanded in b around inf 67.9%
unpow267.9%
Simplified67.9%
div-inv67.8%
Applied egg-rr67.8%
inv-pow67.8%
associate-*r*76.0%
unpow-prod-down75.6%
inv-pow75.6%
Applied egg-rr75.6%
associate-*r/75.6%
*-rgt-identity75.6%
unpow-175.6%
Simplified75.6%
Final simplification79.8%
(FPCore (a b)
:precision binary64
(let* ((t_0 (* (/ (/ PI (* a b)) (- b a)) (- 0.5))))
(if (<= a -3.3e-24)
t_0
(if (<= a -2.8e-58)
(/ (/ (/ PI (- b a)) (+ a b)) (/ a 0.5))
(if (<= a -1.02e-131) t_0 (* 0.5 (* PI (/ (/ 1.0 (* a b)) b))))))))
double code(double a, double b) {
double t_0 = ((((double) M_PI) / (a * b)) / (b - a)) * -0.5;
double tmp;
if (a <= -3.3e-24) {
tmp = t_0;
} else if (a <= -2.8e-58) {
tmp = ((((double) M_PI) / (b - a)) / (a + b)) / (a / 0.5);
} else if (a <= -1.02e-131) {
tmp = t_0;
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double t_0 = ((Math.PI / (a * b)) / (b - a)) * -0.5;
double tmp;
if (a <= -3.3e-24) {
tmp = t_0;
} else if (a <= -2.8e-58) {
tmp = ((Math.PI / (b - a)) / (a + b)) / (a / 0.5);
} else if (a <= -1.02e-131) {
tmp = t_0;
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): t_0 = ((math.pi / (a * b)) / (b - a)) * -0.5 tmp = 0 if a <= -3.3e-24: tmp = t_0 elif a <= -2.8e-58: tmp = ((math.pi / (b - a)) / (a + b)) / (a / 0.5) elif a <= -1.02e-131: tmp = t_0 else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) t_0 = Float64(Float64(Float64(pi / Float64(a * b)) / Float64(b - a)) * Float64(-0.5)) tmp = 0.0 if (a <= -3.3e-24) tmp = t_0; elseif (a <= -2.8e-58) tmp = Float64(Float64(Float64(pi / Float64(b - a)) / Float64(a + b)) / Float64(a / 0.5)); elseif (a <= -1.02e-131) tmp = t_0; else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) t_0 = ((pi / (a * b)) / (b - a)) * -0.5; tmp = 0.0; if (a <= -3.3e-24) tmp = t_0; elseif (a <= -2.8e-58) tmp = ((pi / (b - a)) / (a + b)) / (a / 0.5); elseif (a <= -1.02e-131) tmp = t_0; else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := Block[{t$95$0 = N[(N[(N[(Pi / N[(a * b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision] * (-0.5)), $MachinePrecision]}, If[LessEqual[a, -3.3e-24], t$95$0, If[LessEqual[a, -2.8e-58], N[(N[(N[(Pi / N[(b - a), $MachinePrecision]), $MachinePrecision] / N[(a + b), $MachinePrecision]), $MachinePrecision] / N[(a / 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -1.02e-131], t$95$0, N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{\pi}{a \cdot b}}{b - a} \cdot \left(-0.5\right)\\
\mathbf{if}\;a \leq -3.3 \cdot 10^{-24}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;a \leq -2.8 \cdot 10^{-58}:\\
\;\;\;\;\frac{\frac{\frac{\pi}{b - a}}{a + b}}{\frac{a}{0.5}}\\
\mathbf{elif}\;a \leq -1.02 \cdot 10^{-131}:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -3.29999999999999984e-24 or -2.8000000000000001e-58 < a < -1.02000000000000001e-131Initial program 77.2%
*-commutative77.2%
associate-/r/77.2%
associate-*l/77.3%
*-commutative77.3%
associate-/r/77.3%
times-frac77.3%
Simplified77.4%
clear-num77.3%
inv-pow77.3%
Applied egg-rr77.3%
unpow-177.3%
fma-def77.3%
+-commutative77.3%
associate-*r/77.3%
*-commutative77.3%
associate-*r/77.3%
mul-1-neg77.3%
unsub-neg77.3%
Simplified77.3%
div-sub68.0%
Applied egg-rr68.0%
div-sub77.3%
difference-of-squares87.8%
*-commutative87.8%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u83.0%
expm1-udef57.5%
associate-/r/57.5%
+-commutative57.5%
Applied egg-rr57.5%
expm1-def82.9%
expm1-log1p99.6%
associate-*l/99.7%
*-lft-identity99.7%
Simplified99.7%
Taylor expanded in a around inf 87.1%
associate-*r/87.1%
neg-mul-187.1%
Simplified87.1%
if -3.29999999999999984e-24 < a < -2.8000000000000001e-58Initial program 98.9%
times-frac98.9%
*-commutative98.9%
times-frac98.9%
difference-of-squares98.9%
associate-/r*99.1%
metadata-eval99.1%
sub-neg99.1%
distribute-neg-frac99.1%
metadata-eval99.1%
Simplified99.1%
Taylor expanded in a around 0 83.5%
expm1-log1p-u60.4%
expm1-udef12.0%
un-div-inv12.0%
associate-/l/12.0%
+-commutative12.0%
Applied egg-rr12.0%
expm1-def60.1%
expm1-log1p83.4%
associate-/l*83.4%
associate-/r*83.6%
Simplified83.6%
if -1.02000000000000001e-131 < a Initial program 79.7%
*-commutative79.7%
associate-/r/79.7%
associate-*l/79.8%
*-commutative79.8%
associate-/r/79.8%
times-frac79.8%
Simplified79.7%
Taylor expanded in b around inf 67.9%
unpow267.9%
Simplified67.9%
div-inv67.8%
Applied egg-rr67.8%
inv-pow67.8%
associate-*r*76.0%
unpow-prod-down75.6%
inv-pow75.6%
Applied egg-rr75.6%
associate-*r/75.6%
*-rgt-identity75.6%
unpow-175.6%
Simplified75.6%
Final simplification79.8%
(FPCore (a b) :precision binary64 (if (<= a -4.5e-28) (* (/ (/ PI (* a b)) (- b a)) (- 0.5)) (* 0.5 (* PI (/ (/ 1.0 (* a b)) b)))))
double code(double a, double b) {
double tmp;
if (a <= -4.5e-28) {
tmp = ((((double) M_PI) / (a * b)) / (b - a)) * -0.5;
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -4.5e-28) {
tmp = ((Math.PI / (a * b)) / (b - a)) * -0.5;
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -4.5e-28: tmp = ((math.pi / (a * b)) / (b - a)) * -0.5 else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -4.5e-28) tmp = Float64(Float64(Float64(pi / Float64(a * b)) / Float64(b - a)) * Float64(-0.5)); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -4.5e-28) tmp = ((pi / (a * b)) / (b - a)) * -0.5; else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -4.5e-28], N[(N[(N[(Pi / N[(a * b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision] * (-0.5)), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -4.5 \cdot 10^{-28}:\\
\;\;\;\;\frac{\frac{\pi}{a \cdot b}}{b - a} \cdot \left(-0.5\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -4.4999999999999998e-28Initial program 76.4%
*-commutative76.4%
associate-/r/76.4%
associate-*l/76.5%
*-commutative76.5%
associate-/r/76.5%
times-frac76.5%
Simplified76.6%
clear-num76.6%
inv-pow76.6%
Applied egg-rr76.6%
unpow-176.6%
fma-def76.5%
+-commutative76.5%
associate-*r/76.6%
*-commutative76.6%
associate-*r/76.6%
mul-1-neg76.6%
unsub-neg76.6%
Simplified76.6%
div-sub69.9%
Applied egg-rr69.9%
div-sub76.6%
difference-of-squares88.5%
*-commutative88.5%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u88.4%
expm1-udef61.6%
associate-/r/61.6%
+-commutative61.6%
Applied egg-rr61.6%
expm1-def88.3%
expm1-log1p99.6%
associate-*l/99.8%
*-lft-identity99.8%
Simplified99.8%
Taylor expanded in a around inf 91.8%
associate-*r/91.8%
neg-mul-191.8%
Simplified91.8%
if -4.4999999999999998e-28 < a Initial program 81.0%
*-commutative81.0%
associate-/r/80.9%
associate-*l/81.0%
*-commutative81.0%
associate-/r/81.0%
times-frac81.0%
Simplified81.0%
Taylor expanded in b around inf 68.5%
unpow268.5%
Simplified68.5%
div-inv68.4%
Applied egg-rr68.4%
inv-pow68.4%
associate-*r*76.7%
unpow-prod-down76.4%
inv-pow76.4%
Applied egg-rr76.4%
associate-*r/76.4%
*-rgt-identity76.4%
unpow-176.4%
Simplified76.4%
Final simplification80.9%
(FPCore (a b) :precision binary64 (if (<= a -1.55e-30) (* 0.5 (/ PI (* a (* a b)))) (* 0.5 (* PI (/ (/ 1.0 (* a b)) b)))))
double code(double a, double b) {
double tmp;
if (a <= -1.55e-30) {
tmp = 0.5 * (((double) M_PI) / (a * (a * b)));
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -1.55e-30) {
tmp = 0.5 * (Math.PI / (a * (a * b)));
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -1.55e-30: tmp = 0.5 * (math.pi / (a * (a * b))) else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -1.55e-30) tmp = Float64(0.5 * Float64(pi / Float64(a * Float64(a * b)))); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -1.55e-30) tmp = 0.5 * (pi / (a * (a * b))); else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -1.55e-30], N[(0.5 * N[(Pi / N[(a * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.55 \cdot 10^{-30}:\\
\;\;\;\;0.5 \cdot \frac{\pi}{a \cdot \left(a \cdot b\right)}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -1.54999999999999995e-30Initial program 76.4%
*-commutative76.4%
associate-/r/76.4%
associate-*l/76.5%
*-commutative76.5%
associate-/r/76.5%
times-frac76.5%
Simplified76.6%
clear-num76.6%
inv-pow76.6%
Applied egg-rr76.6%
unpow-176.6%
fma-def76.5%
+-commutative76.5%
associate-*r/76.6%
*-commutative76.6%
associate-*r/76.6%
mul-1-neg76.6%
unsub-neg76.6%
Simplified76.6%
div-sub69.9%
Applied egg-rr69.9%
div-sub76.6%
difference-of-squares88.5%
*-commutative88.5%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u88.4%
expm1-udef61.6%
associate-/r/61.6%
+-commutative61.6%
Applied egg-rr61.6%
expm1-def88.3%
expm1-log1p99.6%
associate-*l/99.8%
*-lft-identity99.8%
Simplified99.8%
Taylor expanded in a around inf 73.0%
unpow273.0%
associate-*l*84.2%
Simplified84.2%
if -1.54999999999999995e-30 < a Initial program 81.0%
*-commutative81.0%
associate-/r/80.9%
associate-*l/81.0%
*-commutative81.0%
associate-/r/81.0%
times-frac81.0%
Simplified81.0%
Taylor expanded in b around inf 68.5%
unpow268.5%
Simplified68.5%
div-inv68.4%
Applied egg-rr68.4%
inv-pow68.4%
associate-*r*76.7%
unpow-prod-down76.4%
inv-pow76.4%
Applied egg-rr76.4%
associate-*r/76.4%
*-rgt-identity76.4%
unpow-176.4%
Simplified76.4%
Final simplification78.7%
(FPCore (a b) :precision binary64 (if (<= a -1.15e-29) (* 0.5 (/ 1.0 (* a (/ a (/ PI b))))) (* 0.5 (* PI (/ (/ 1.0 (* a b)) b)))))
double code(double a, double b) {
double tmp;
if (a <= -1.15e-29) {
tmp = 0.5 * (1.0 / (a * (a / (((double) M_PI) / b))));
} else {
tmp = 0.5 * (((double) M_PI) * ((1.0 / (a * b)) / b));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -1.15e-29) {
tmp = 0.5 * (1.0 / (a * (a / (Math.PI / b))));
} else {
tmp = 0.5 * (Math.PI * ((1.0 / (a * b)) / b));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -1.15e-29: tmp = 0.5 * (1.0 / (a * (a / (math.pi / b)))) else: tmp = 0.5 * (math.pi * ((1.0 / (a * b)) / b)) return tmp
function code(a, b) tmp = 0.0 if (a <= -1.15e-29) tmp = Float64(0.5 * Float64(1.0 / Float64(a * Float64(a / Float64(pi / b))))); else tmp = Float64(0.5 * Float64(pi * Float64(Float64(1.0 / Float64(a * b)) / b))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -1.15e-29) tmp = 0.5 * (1.0 / (a * (a / (pi / b)))); else tmp = 0.5 * (pi * ((1.0 / (a * b)) / b)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -1.15e-29], N[(0.5 * N[(1.0 / N[(a * N[(a / N[(Pi / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(Pi * N[(N[(1.0 / N[(a * b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.15 \cdot 10^{-29}:\\
\;\;\;\;0.5 \cdot \frac{1}{a \cdot \frac{a}{\frac{\pi}{b}}}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \left(\pi \cdot \frac{\frac{1}{a \cdot b}}{b}\right)\\
\end{array}
\end{array}
if a < -1.14999999999999996e-29Initial program 76.4%
*-commutative76.4%
associate-/r/76.4%
associate-*l/76.5%
*-commutative76.5%
associate-/r/76.5%
times-frac76.5%
Simplified76.6%
clear-num76.6%
inv-pow76.6%
Applied egg-rr76.6%
unpow-176.6%
fma-def76.5%
+-commutative76.5%
associate-*r/76.6%
*-commutative76.6%
associate-*r/76.6%
mul-1-neg76.6%
unsub-neg76.6%
Simplified76.6%
Taylor expanded in b around 0 73.1%
unpow273.1%
associate-/l*73.1%
*-lft-identity73.1%
times-frac84.3%
/-rgt-identity84.3%
Simplified84.3%
if -1.14999999999999996e-29 < a Initial program 81.0%
*-commutative81.0%
associate-/r/80.9%
associate-*l/81.0%
*-commutative81.0%
associate-/r/81.0%
times-frac81.0%
Simplified81.0%
Taylor expanded in b around inf 68.5%
unpow268.5%
Simplified68.5%
div-inv68.4%
Applied egg-rr68.4%
inv-pow68.4%
associate-*r*76.7%
unpow-prod-down76.4%
inv-pow76.4%
Applied egg-rr76.4%
associate-*r/76.4%
*-rgt-identity76.4%
unpow-176.4%
Simplified76.4%
Final simplification78.7%
(FPCore (a b) :precision binary64 (if (<= b 4.5e-155) (* 0.5 (/ 1.0 (* a (/ a (/ PI b))))) (* 0.5 (/ (/ PI (* a b)) (- b a)))))
double code(double a, double b) {
double tmp;
if (b <= 4.5e-155) {
tmp = 0.5 * (1.0 / (a * (a / (((double) M_PI) / b))));
} else {
tmp = 0.5 * ((((double) M_PI) / (a * b)) / (b - a));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (b <= 4.5e-155) {
tmp = 0.5 * (1.0 / (a * (a / (Math.PI / b))));
} else {
tmp = 0.5 * ((Math.PI / (a * b)) / (b - a));
}
return tmp;
}
def code(a, b): tmp = 0 if b <= 4.5e-155: tmp = 0.5 * (1.0 / (a * (a / (math.pi / b)))) else: tmp = 0.5 * ((math.pi / (a * b)) / (b - a)) return tmp
function code(a, b) tmp = 0.0 if (b <= 4.5e-155) tmp = Float64(0.5 * Float64(1.0 / Float64(a * Float64(a / Float64(pi / b))))); else tmp = Float64(0.5 * Float64(Float64(pi / Float64(a * b)) / Float64(b - a))); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (b <= 4.5e-155) tmp = 0.5 * (1.0 / (a * (a / (pi / b)))); else tmp = 0.5 * ((pi / (a * b)) / (b - a)); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[b, 4.5e-155], N[(0.5 * N[(1.0 / N[(a * N[(a / N[(Pi / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(N[(Pi / N[(a * b), $MachinePrecision]), $MachinePrecision] / N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 4.5 \cdot 10^{-155}:\\
\;\;\;\;0.5 \cdot \frac{1}{a \cdot \frac{a}{\frac{\pi}{b}}}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{\frac{\pi}{a \cdot b}}{b - a}\\
\end{array}
\end{array}
if b < 4.5000000000000004e-155Initial program 78.5%
*-commutative78.5%
associate-/r/78.5%
associate-*l/78.6%
*-commutative78.6%
associate-/r/78.6%
times-frac78.6%
Simplified78.6%
clear-num78.6%
inv-pow78.6%
Applied egg-rr78.6%
unpow-178.6%
fma-def78.6%
+-commutative78.6%
associate-*r/78.6%
*-commutative78.6%
associate-*r/78.6%
mul-1-neg78.6%
unsub-neg78.6%
Simplified78.6%
Taylor expanded in b around 0 59.8%
unpow259.8%
associate-/l*59.8%
*-lft-identity59.8%
times-frac65.2%
/-rgt-identity65.2%
Simplified65.2%
if 4.5000000000000004e-155 < b Initial program 81.3%
*-commutative81.3%
associate-/r/81.3%
associate-*l/81.4%
*-commutative81.4%
associate-/r/81.4%
times-frac81.4%
Simplified81.4%
clear-num81.4%
inv-pow81.4%
Applied egg-rr81.4%
unpow-181.4%
fma-def81.3%
+-commutative81.3%
associate-*r/81.4%
*-commutative81.4%
associate-*r/81.4%
mul-1-neg81.4%
unsub-neg81.4%
Simplified81.4%
div-sub69.5%
Applied egg-rr69.5%
div-sub81.4%
difference-of-squares89.3%
*-commutative89.3%
associate-/l*99.5%
Simplified99.5%
expm1-log1p-u88.0%
expm1-udef57.7%
associate-/r/57.7%
+-commutative57.7%
Applied egg-rr57.7%
expm1-def88.1%
expm1-log1p99.6%
associate-*l/99.6%
*-lft-identity99.6%
Simplified99.6%
Taylor expanded in a around 0 81.8%
Final simplification71.8%
(FPCore (a b) :precision binary64 (if (<= a -1.8e-25) (* 0.5 (/ PI (* a (* a b)))) (* 0.5 (/ PI (* a (* b b))))))
double code(double a, double b) {
double tmp;
if (a <= -1.8e-25) {
tmp = 0.5 * (((double) M_PI) / (a * (a * b)));
} else {
tmp = 0.5 * (((double) M_PI) / (a * (b * b)));
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -1.8e-25) {
tmp = 0.5 * (Math.PI / (a * (a * b)));
} else {
tmp = 0.5 * (Math.PI / (a * (b * b)));
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -1.8e-25: tmp = 0.5 * (math.pi / (a * (a * b))) else: tmp = 0.5 * (math.pi / (a * (b * b))) return tmp
function code(a, b) tmp = 0.0 if (a <= -1.8e-25) tmp = Float64(0.5 * Float64(pi / Float64(a * Float64(a * b)))); 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 <= -1.8e-25) tmp = 0.5 * (pi / (a * (a * b))); else tmp = 0.5 * (pi / (a * (b * b))); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -1.8e-25], N[(0.5 * N[(Pi / N[(a * N[(a * b), $MachinePrecision]), $MachinePrecision]), $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 -1.8 \cdot 10^{-25}:\\
\;\;\;\;0.5 \cdot \frac{\pi}{a \cdot \left(a \cdot b\right)}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{\pi}{a \cdot \left(b \cdot b\right)}\\
\end{array}
\end{array}
if a < -1.8e-25Initial program 76.4%
*-commutative76.4%
associate-/r/76.4%
associate-*l/76.5%
*-commutative76.5%
associate-/r/76.5%
times-frac76.5%
Simplified76.6%
clear-num76.6%
inv-pow76.6%
Applied egg-rr76.6%
unpow-176.6%
fma-def76.5%
+-commutative76.5%
associate-*r/76.6%
*-commutative76.6%
associate-*r/76.6%
mul-1-neg76.6%
unsub-neg76.6%
Simplified76.6%
div-sub69.9%
Applied egg-rr69.9%
div-sub76.6%
difference-of-squares88.5%
*-commutative88.5%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u88.4%
expm1-udef61.6%
associate-/r/61.6%
+-commutative61.6%
Applied egg-rr61.6%
expm1-def88.3%
expm1-log1p99.6%
associate-*l/99.8%
*-lft-identity99.8%
Simplified99.8%
Taylor expanded in a around inf 73.0%
unpow273.0%
associate-*l*84.2%
Simplified84.2%
if -1.8e-25 < a Initial program 81.0%
*-commutative81.0%
associate-/r/80.9%
associate-*l/81.0%
*-commutative81.0%
associate-/r/81.0%
times-frac81.0%
Simplified81.0%
Taylor expanded in b around inf 68.5%
unpow268.5%
Simplified68.5%
Final simplification73.1%
(FPCore (a b) :precision binary64 (if (<= a -1.55e-30) (* 0.5 (/ PI (* a (* a b)))) (/ PI (/ (* b (* a b)) 0.5))))
double code(double a, double b) {
double tmp;
if (a <= -1.55e-30) {
tmp = 0.5 * (((double) M_PI) / (a * (a * b)));
} else {
tmp = ((double) M_PI) / ((b * (a * b)) / 0.5);
}
return tmp;
}
public static double code(double a, double b) {
double tmp;
if (a <= -1.55e-30) {
tmp = 0.5 * (Math.PI / (a * (a * b)));
} else {
tmp = Math.PI / ((b * (a * b)) / 0.5);
}
return tmp;
}
def code(a, b): tmp = 0 if a <= -1.55e-30: tmp = 0.5 * (math.pi / (a * (a * b))) else: tmp = math.pi / ((b * (a * b)) / 0.5) return tmp
function code(a, b) tmp = 0.0 if (a <= -1.55e-30) tmp = Float64(0.5 * Float64(pi / Float64(a * Float64(a * b)))); else tmp = Float64(pi / Float64(Float64(b * Float64(a * b)) / 0.5)); end return tmp end
function tmp_2 = code(a, b) tmp = 0.0; if (a <= -1.55e-30) tmp = 0.5 * (pi / (a * (a * b))); else tmp = pi / ((b * (a * b)) / 0.5); end tmp_2 = tmp; end
code[a_, b_] := If[LessEqual[a, -1.55e-30], N[(0.5 * N[(Pi / N[(a * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(Pi / N[(N[(b * N[(a * b), $MachinePrecision]), $MachinePrecision] / 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.55 \cdot 10^{-30}:\\
\;\;\;\;0.5 \cdot \frac{\pi}{a \cdot \left(a \cdot b\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\pi}{\frac{b \cdot \left(a \cdot b\right)}{0.5}}\\
\end{array}
\end{array}
if a < -1.54999999999999995e-30Initial program 76.4%
*-commutative76.4%
associate-/r/76.4%
associate-*l/76.5%
*-commutative76.5%
associate-/r/76.5%
times-frac76.5%
Simplified76.6%
clear-num76.6%
inv-pow76.6%
Applied egg-rr76.6%
unpow-176.6%
fma-def76.5%
+-commutative76.5%
associate-*r/76.6%
*-commutative76.6%
associate-*r/76.6%
mul-1-neg76.6%
unsub-neg76.6%
Simplified76.6%
div-sub69.9%
Applied egg-rr69.9%
div-sub76.6%
difference-of-squares88.5%
*-commutative88.5%
associate-/l*99.7%
Simplified99.7%
expm1-log1p-u88.4%
expm1-udef61.6%
associate-/r/61.6%
+-commutative61.6%
Applied egg-rr61.6%
expm1-def88.3%
expm1-log1p99.6%
associate-*l/99.8%
*-lft-identity99.8%
Simplified99.8%
Taylor expanded in a around inf 73.0%
unpow273.0%
associate-*l*84.2%
Simplified84.2%
if -1.54999999999999995e-30 < a Initial program 81.0%
times-frac81.0%
*-commutative81.0%
times-frac81.0%
difference-of-squares89.3%
associate-/r*89.6%
metadata-eval89.6%
sub-neg89.6%
distribute-neg-frac89.6%
metadata-eval89.6%
Simplified89.6%
frac-add89.6%
*-un-lft-identity89.6%
Applied egg-rr89.6%
*-commutative89.6%
neg-mul-189.6%
sub-neg89.6%
Simplified89.6%
Taylor expanded in b around inf 68.5%
associate-*r/68.5%
*-commutative68.5%
unpow268.5%
associate-/l*68.5%
*-commutative68.5%
associate-*l*76.7%
Simplified76.7%
Final simplification78.9%
(FPCore (a b) :precision binary64 (* 0.5 (/ (/ PI b) (* a a))))
double code(double a, double b) {
return 0.5 * ((((double) M_PI) / b) / (a * a));
}
public static double code(double a, double b) {
return 0.5 * ((Math.PI / b) / (a * a));
}
def code(a, b): return 0.5 * ((math.pi / b) / (a * a))
function code(a, b) return Float64(0.5 * Float64(Float64(pi / b) / Float64(a * a))) end
function tmp = code(a, b) tmp = 0.5 * ((pi / b) / (a * a)); end
code[a_, b_] := N[(0.5 * N[(N[(Pi / b), $MachinePrecision] / N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \frac{\frac{\pi}{b}}{a \cdot a}
\end{array}
Initial program 79.6%
times-frac79.7%
*-commutative79.7%
times-frac79.7%
difference-of-squares89.1%
associate-/r*90.0%
metadata-eval90.0%
sub-neg90.0%
distribute-neg-frac90.0%
metadata-eval90.0%
Simplified90.0%
frac-add90.0%
*-un-lft-identity90.0%
Applied egg-rr90.0%
*-commutative90.0%
neg-mul-190.0%
sub-neg90.0%
Simplified90.0%
Taylor expanded in b around 0 55.4%
unpow255.4%
*-commutative55.4%
associate-/r*55.4%
Simplified55.4%
Final simplification55.4%
(FPCore (a b) :precision binary64 (* 0.5 (/ (/ (/ PI a) a) b)))
double code(double a, double b) {
return 0.5 * (((((double) M_PI) / a) / a) / b);
}
public static double code(double a, double b) {
return 0.5 * (((Math.PI / a) / a) / b);
}
def code(a, b): return 0.5 * (((math.pi / a) / a) / b)
function code(a, b) return Float64(0.5 * Float64(Float64(Float64(pi / a) / a) / b)) end
function tmp = code(a, b) tmp = 0.5 * (((pi / a) / a) / b); end
code[a_, b_] := N[(0.5 * N[(N[(N[(Pi / a), $MachinePrecision] / a), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \frac{\frac{\frac{\pi}{a}}{a}}{b}
\end{array}
Initial program 79.6%
times-frac79.7%
*-commutative79.7%
times-frac79.7%
difference-of-squares89.1%
associate-/r*90.0%
metadata-eval90.0%
sub-neg90.0%
distribute-neg-frac90.0%
metadata-eval90.0%
Simplified90.0%
frac-add90.0%
*-un-lft-identity90.0%
Applied egg-rr90.0%
*-commutative90.0%
neg-mul-190.0%
sub-neg90.0%
Simplified90.0%
Taylor expanded in b around 0 55.4%
unpow255.4%
associate-/r*55.4%
associate-/r*56.1%
Simplified56.1%
Final simplification56.1%
(FPCore (a b) :precision binary64 (* 0.5 (/ PI (* a (* a b)))))
double code(double a, double b) {
return 0.5 * (((double) M_PI) / (a * (a * b)));
}
public static double code(double a, double b) {
return 0.5 * (Math.PI / (a * (a * b)));
}
def code(a, b): return 0.5 * (math.pi / (a * (a * b)))
function code(a, b) return Float64(0.5 * Float64(pi / Float64(a * Float64(a * b)))) end
function tmp = code(a, b) tmp = 0.5 * (pi / (a * (a * b))); end
code[a_, b_] := N[(0.5 * N[(Pi / N[(a * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \frac{\pi}{a \cdot \left(a \cdot b\right)}
\end{array}
Initial program 79.6%
*-commutative79.6%
associate-/r/79.6%
associate-*l/79.7%
*-commutative79.7%
associate-/r/79.7%
times-frac79.7%
Simplified79.7%
clear-num79.7%
inv-pow79.7%
Applied egg-rr79.7%
unpow-179.7%
fma-def79.7%
+-commutative79.7%
associate-*r/79.7%
*-commutative79.7%
associate-*r/79.7%
mul-1-neg79.7%
unsub-neg79.7%
Simplified79.7%
div-sub68.0%
Applied egg-rr68.0%
div-sub79.7%
difference-of-squares89.0%
*-commutative89.0%
associate-/l*99.6%
Simplified99.6%
expm1-log1p-u77.8%
expm1-udef51.8%
associate-/r/51.8%
+-commutative51.8%
Applied egg-rr51.8%
expm1-def77.9%
expm1-log1p99.6%
associate-*l/99.7%
*-lft-identity99.7%
Simplified99.7%
Taylor expanded in a around inf 55.4%
unpow255.4%
associate-*l*60.1%
Simplified60.1%
Final simplification60.1%
herbie shell --seed 2023208
(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))))