
(FPCore (F l) :precision binary64 (- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))
double code(double F, double l) {
return (((double) M_PI) * l) - ((1.0 / (F * F)) * tan((((double) M_PI) * l)));
}
public static double code(double F, double l) {
return (Math.PI * l) - ((1.0 / (F * F)) * Math.tan((Math.PI * l)));
}
def code(F, l): return (math.pi * l) - ((1.0 / (F * F)) * math.tan((math.pi * l)))
function code(F, l) return Float64(Float64(pi * l) - Float64(Float64(1.0 / Float64(F * F)) * tan(Float64(pi * l)))) end
function tmp = code(F, l) tmp = (pi * l) - ((1.0 / (F * F)) * tan((pi * l))); end
code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(1.0 / N[(F * F), $MachinePrecision]), $MachinePrecision] * N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\pi \cdot \ell - \frac{1}{F \cdot F} \cdot \tan \left(\pi \cdot \ell\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (F l) :precision binary64 (- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))
double code(double F, double l) {
return (((double) M_PI) * l) - ((1.0 / (F * F)) * tan((((double) M_PI) * l)));
}
public static double code(double F, double l) {
return (Math.PI * l) - ((1.0 / (F * F)) * Math.tan((Math.PI * l)));
}
def code(F, l): return (math.pi * l) - ((1.0 / (F * F)) * math.tan((math.pi * l)))
function code(F, l) return Float64(Float64(pi * l) - Float64(Float64(1.0 / Float64(F * F)) * tan(Float64(pi * l)))) end
function tmp = code(F, l) tmp = (pi * l) - ((1.0 / (F * F)) * tan((pi * l))); end
code[F_, l_] := N[(N[(Pi * l), $MachinePrecision] - N[(N[(1.0 / N[(F * F), $MachinePrecision]), $MachinePrecision] * N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\pi \cdot \ell - \frac{1}{F \cdot F} \cdot \tan \left(\pi \cdot \ell\right)
\end{array}
(FPCore (F l) :precision binary64 (if (or (<= (* PI l) -5e+23) (not (<= (* PI l) 50.0))) (* PI l) (- (* PI l) (/ (/ (tan (* PI l)) F) F))))
double code(double F, double l) {
double tmp;
if (((((double) M_PI) * l) <= -5e+23) || !((((double) M_PI) * l) <= 50.0)) {
tmp = ((double) M_PI) * l;
} else {
tmp = (((double) M_PI) * l) - ((tan((((double) M_PI) * l)) / F) / F);
}
return tmp;
}
public static double code(double F, double l) {
double tmp;
if (((Math.PI * l) <= -5e+23) || !((Math.PI * l) <= 50.0)) {
tmp = Math.PI * l;
} else {
tmp = (Math.PI * l) - ((Math.tan((Math.PI * l)) / F) / F);
}
return tmp;
}
def code(F, l): tmp = 0 if ((math.pi * l) <= -5e+23) or not ((math.pi * l) <= 50.0): tmp = math.pi * l else: tmp = (math.pi * l) - ((math.tan((math.pi * l)) / F) / F) return tmp
function code(F, l) tmp = 0.0 if ((Float64(pi * l) <= -5e+23) || !(Float64(pi * l) <= 50.0)) tmp = Float64(pi * l); else tmp = Float64(Float64(pi * l) - Float64(Float64(tan(Float64(pi * l)) / F) / F)); end return tmp end
function tmp_2 = code(F, l) tmp = 0.0; if (((pi * l) <= -5e+23) || ~(((pi * l) <= 50.0))) tmp = pi * l; else tmp = (pi * l) - ((tan((pi * l)) / F) / F); end tmp_2 = tmp; end
code[F_, l_] := If[Or[LessEqual[N[(Pi * l), $MachinePrecision], -5e+23], N[Not[LessEqual[N[(Pi * l), $MachinePrecision], 50.0]], $MachinePrecision]], N[(Pi * l), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[(N[Tan[N[(Pi * l), $MachinePrecision]], $MachinePrecision] / F), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\pi \cdot \ell \leq -5 \cdot 10^{+23} \lor \neg \left(\pi \cdot \ell \leq 50\right):\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\tan \left(\pi \cdot \ell\right)}{F}}{F}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < -4.9999999999999999e23 or 50 < (*.f64 (PI.f64) l) Initial program 63.5%
Taylor expanded in l around 0 46.0%
unpow246.0%
times-frac46.0%
Simplified46.0%
Taylor expanded in F around inf 99.5%
if -4.9999999999999999e23 < (*.f64 (PI.f64) l) < 50Initial program 86.1%
associate-*l/86.5%
*-un-lft-identity86.5%
associate-/r*99.5%
Applied egg-rr99.5%
Final simplification99.5%
(FPCore (F l) :precision binary64 (if (or (<= (* PI l) -5e+23) (not (<= (* PI l) 1e-13))) (* PI l) (- (* PI l) (/ (/ l F) (/ F PI)))))
double code(double F, double l) {
double tmp;
if (((((double) M_PI) * l) <= -5e+23) || !((((double) M_PI) * l) <= 1e-13)) {
tmp = ((double) M_PI) * l;
} else {
tmp = (((double) M_PI) * l) - ((l / F) / (F / ((double) M_PI)));
}
return tmp;
}
public static double code(double F, double l) {
double tmp;
if (((Math.PI * l) <= -5e+23) || !((Math.PI * l) <= 1e-13)) {
tmp = Math.PI * l;
} else {
tmp = (Math.PI * l) - ((l / F) / (F / Math.PI));
}
return tmp;
}
def code(F, l): tmp = 0 if ((math.pi * l) <= -5e+23) or not ((math.pi * l) <= 1e-13): tmp = math.pi * l else: tmp = (math.pi * l) - ((l / F) / (F / math.pi)) return tmp
function code(F, l) tmp = 0.0 if ((Float64(pi * l) <= -5e+23) || !(Float64(pi * l) <= 1e-13)) tmp = Float64(pi * l); else tmp = Float64(Float64(pi * l) - Float64(Float64(l / F) / Float64(F / pi))); end return tmp end
function tmp_2 = code(F, l) tmp = 0.0; if (((pi * l) <= -5e+23) || ~(((pi * l) <= 1e-13))) tmp = pi * l; else tmp = (pi * l) - ((l / F) / (F / pi)); end tmp_2 = tmp; end
code[F_, l_] := If[Or[LessEqual[N[(Pi * l), $MachinePrecision], -5e+23], N[Not[LessEqual[N[(Pi * l), $MachinePrecision], 1e-13]], $MachinePrecision]], N[(Pi * l), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[(l / F), $MachinePrecision] / N[(F / Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\pi \cdot \ell \leq -5 \cdot 10^{+23} \lor \neg \left(\pi \cdot \ell \leq 10^{-13}\right):\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\frac{\ell}{F}}{\frac{F}{\pi}}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < -4.9999999999999999e23 or 1e-13 < (*.f64 (PI.f64) l) Initial program 63.8%
Taylor expanded in l around 0 45.7%
unpow245.7%
times-frac45.7%
Simplified45.7%
Taylor expanded in F around inf 98.8%
if -4.9999999999999999e23 < (*.f64 (PI.f64) l) < 1e-13Initial program 86.0%
Taylor expanded in l around 0 86.4%
unpow286.4%
times-frac99.4%
Simplified99.4%
clear-num99.5%
un-div-inv99.6%
Applied egg-rr99.6%
Final simplification99.2%
(FPCore (F l)
:precision binary64
(let* ((t_0 (* l (- PI (/ PI (* F F))))))
(if (<= l -2.65e+17)
(* PI l)
(if (<= l -2.8e-175)
t_0
(if (<= l -1.55e-257)
(* (/ PI F) (- (/ l F)))
(if (<= l 5.5) t_0 (* PI l)))))))
double code(double F, double l) {
double t_0 = l * (((double) M_PI) - (((double) M_PI) / (F * F)));
double tmp;
if (l <= -2.65e+17) {
tmp = ((double) M_PI) * l;
} else if (l <= -2.8e-175) {
tmp = t_0;
} else if (l <= -1.55e-257) {
tmp = (((double) M_PI) / F) * -(l / F);
} else if (l <= 5.5) {
tmp = t_0;
} else {
tmp = ((double) M_PI) * l;
}
return tmp;
}
public static double code(double F, double l) {
double t_0 = l * (Math.PI - (Math.PI / (F * F)));
double tmp;
if (l <= -2.65e+17) {
tmp = Math.PI * l;
} else if (l <= -2.8e-175) {
tmp = t_0;
} else if (l <= -1.55e-257) {
tmp = (Math.PI / F) * -(l / F);
} else if (l <= 5.5) {
tmp = t_0;
} else {
tmp = Math.PI * l;
}
return tmp;
}
def code(F, l): t_0 = l * (math.pi - (math.pi / (F * F))) tmp = 0 if l <= -2.65e+17: tmp = math.pi * l elif l <= -2.8e-175: tmp = t_0 elif l <= -1.55e-257: tmp = (math.pi / F) * -(l / F) elif l <= 5.5: tmp = t_0 else: tmp = math.pi * l return tmp
function code(F, l) t_0 = Float64(l * Float64(pi - Float64(pi / Float64(F * F)))) tmp = 0.0 if (l <= -2.65e+17) tmp = Float64(pi * l); elseif (l <= -2.8e-175) tmp = t_0; elseif (l <= -1.55e-257) tmp = Float64(Float64(pi / F) * Float64(-Float64(l / F))); elseif (l <= 5.5) tmp = t_0; else tmp = Float64(pi * l); end return tmp end
function tmp_2 = code(F, l) t_0 = l * (pi - (pi / (F * F))); tmp = 0.0; if (l <= -2.65e+17) tmp = pi * l; elseif (l <= -2.8e-175) tmp = t_0; elseif (l <= -1.55e-257) tmp = (pi / F) * -(l / F); elseif (l <= 5.5) tmp = t_0; else tmp = pi * l; end tmp_2 = tmp; end
code[F_, l_] := Block[{t$95$0 = N[(l * N[(Pi - N[(Pi / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -2.65e+17], N[(Pi * l), $MachinePrecision], If[LessEqual[l, -2.8e-175], t$95$0, If[LessEqual[l, -1.55e-257], N[(N[(Pi / F), $MachinePrecision] * (-N[(l / F), $MachinePrecision])), $MachinePrecision], If[LessEqual[l, 5.5], t$95$0, N[(Pi * l), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \ell \cdot \left(\pi - \frac{\pi}{F \cdot F}\right)\\
\mathbf{if}\;\ell \leq -2.65 \cdot 10^{+17}:\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{elif}\;\ell \leq -2.8 \cdot 10^{-175}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\ell \leq -1.55 \cdot 10^{-257}:\\
\;\;\;\;\frac{\pi}{F} \cdot \left(-\frac{\ell}{F}\right)\\
\mathbf{elif}\;\ell \leq 5.5:\\
\;\;\;\;t_0\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell\\
\end{array}
\end{array}
if l < -2.65e17 or 5.5 < l Initial program 63.8%
Taylor expanded in l around 0 45.7%
unpow245.7%
times-frac45.7%
Simplified45.7%
Taylor expanded in F around inf 98.8%
if -2.65e17 < l < -2.8e-175 or -1.55000000000000004e-257 < l < 5.5Initial program 91.4%
Taylor expanded in l around 0 91.4%
unpow291.4%
times-frac99.4%
Simplified99.4%
Taylor expanded in l around 0 91.3%
unpow291.3%
Simplified91.3%
if -2.8e-175 < l < -1.55000000000000004e-257Initial program 49.7%
Taylor expanded in l around 0 52.4%
unpow252.4%
times-frac99.5%
Simplified99.5%
Taylor expanded in F around 0 33.6%
unpow233.6%
associate-*r/33.6%
mul-1-neg33.6%
distribute-rgt-neg-out33.6%
Simplified33.6%
associate-/l*33.1%
associate-/r/33.5%
associate-/l/80.7%
add-sqr-sqrt0.0%
sqrt-unprod1.8%
sqr-neg1.8%
sqrt-unprod1.8%
add-sqr-sqrt1.8%
associate-/r/1.8%
frac-2neg1.8%
div-inv1.8%
distribute-neg-frac1.8%
distribute-neg-frac1.8%
add-sqr-sqrt1.8%
sqrt-unprod1.8%
sqr-neg1.8%
sqrt-unprod0.0%
add-sqr-sqrt80.8%
frac-2neg80.8%
clear-num80.7%
remove-double-div80.7%
Applied egg-rr80.7%
Final simplification94.8%
(FPCore (F l)
:precision binary64
(if (<= l -2.65e+17)
(* PI l)
(if (<= l -6e-174)
(* PI (- l (* l (pow F -2.0))))
(if (<= l -2.25e-263)
(* (/ PI F) (- (/ l F)))
(if (<= l 5.5) (* l (- PI (/ PI (* F F)))) (* PI l))))))
double code(double F, double l) {
double tmp;
if (l <= -2.65e+17) {
tmp = ((double) M_PI) * l;
} else if (l <= -6e-174) {
tmp = ((double) M_PI) * (l - (l * pow(F, -2.0)));
} else if (l <= -2.25e-263) {
tmp = (((double) M_PI) / F) * -(l / F);
} else if (l <= 5.5) {
tmp = l * (((double) M_PI) - (((double) M_PI) / (F * F)));
} else {
tmp = ((double) M_PI) * l;
}
return tmp;
}
public static double code(double F, double l) {
double tmp;
if (l <= -2.65e+17) {
tmp = Math.PI * l;
} else if (l <= -6e-174) {
tmp = Math.PI * (l - (l * Math.pow(F, -2.0)));
} else if (l <= -2.25e-263) {
tmp = (Math.PI / F) * -(l / F);
} else if (l <= 5.5) {
tmp = l * (Math.PI - (Math.PI / (F * F)));
} else {
tmp = Math.PI * l;
}
return tmp;
}
def code(F, l): tmp = 0 if l <= -2.65e+17: tmp = math.pi * l elif l <= -6e-174: tmp = math.pi * (l - (l * math.pow(F, -2.0))) elif l <= -2.25e-263: tmp = (math.pi / F) * -(l / F) elif l <= 5.5: tmp = l * (math.pi - (math.pi / (F * F))) else: tmp = math.pi * l return tmp
function code(F, l) tmp = 0.0 if (l <= -2.65e+17) tmp = Float64(pi * l); elseif (l <= -6e-174) tmp = Float64(pi * Float64(l - Float64(l * (F ^ -2.0)))); elseif (l <= -2.25e-263) tmp = Float64(Float64(pi / F) * Float64(-Float64(l / F))); elseif (l <= 5.5) tmp = Float64(l * Float64(pi - Float64(pi / Float64(F * F)))); else tmp = Float64(pi * l); end return tmp end
function tmp_2 = code(F, l) tmp = 0.0; if (l <= -2.65e+17) tmp = pi * l; elseif (l <= -6e-174) tmp = pi * (l - (l * (F ^ -2.0))); elseif (l <= -2.25e-263) tmp = (pi / F) * -(l / F); elseif (l <= 5.5) tmp = l * (pi - (pi / (F * F))); else tmp = pi * l; end tmp_2 = tmp; end
code[F_, l_] := If[LessEqual[l, -2.65e+17], N[(Pi * l), $MachinePrecision], If[LessEqual[l, -6e-174], N[(Pi * N[(l - N[(l * N[Power[F, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, -2.25e-263], N[(N[(Pi / F), $MachinePrecision] * (-N[(l / F), $MachinePrecision])), $MachinePrecision], If[LessEqual[l, 5.5], N[(l * N[(Pi - N[(Pi / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(Pi * l), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -2.65 \cdot 10^{+17}:\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{elif}\;\ell \leq -6 \cdot 10^{-174}:\\
\;\;\;\;\pi \cdot \left(\ell - \ell \cdot {F}^{-2}\right)\\
\mathbf{elif}\;\ell \leq -2.25 \cdot 10^{-263}:\\
\;\;\;\;\frac{\pi}{F} \cdot \left(-\frac{\ell}{F}\right)\\
\mathbf{elif}\;\ell \leq 5.5:\\
\;\;\;\;\ell \cdot \left(\pi - \frac{\pi}{F \cdot F}\right)\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell\\
\end{array}
\end{array}
if l < -2.65e17 or 5.5 < l Initial program 63.8%
Taylor expanded in l around 0 45.7%
unpow245.7%
times-frac45.7%
Simplified45.7%
Taylor expanded in F around inf 98.8%
if -2.65e17 < l < -6.00000000000000042e-174Initial program 91.9%
Taylor expanded in l around 0 91.9%
unpow291.9%
times-frac99.3%
Simplified99.3%
Taylor expanded in l around 0 91.9%
sub-neg91.9%
mul-1-neg91.9%
distribute-rgt-in91.9%
mul-1-neg91.9%
distribute-lft-neg-in91.9%
unpow291.9%
associate-*l/91.9%
*-commutative91.9%
unpow291.9%
unsub-neg91.9%
unpow291.9%
*-commutative91.9%
*-lft-identity91.9%
associate-*l/91.9%
Simplified92.0%
if -6.00000000000000042e-174 < l < -2.2499999999999999e-263Initial program 49.7%
Taylor expanded in l around 0 52.4%
unpow252.4%
times-frac99.5%
Simplified99.5%
Taylor expanded in F around 0 33.6%
unpow233.6%
associate-*r/33.6%
mul-1-neg33.6%
distribute-rgt-neg-out33.6%
Simplified33.6%
associate-/l*33.1%
associate-/r/33.5%
associate-/l/80.7%
add-sqr-sqrt0.0%
sqrt-unprod1.8%
sqr-neg1.8%
sqrt-unprod1.8%
add-sqr-sqrt1.8%
associate-/r/1.8%
frac-2neg1.8%
div-inv1.8%
distribute-neg-frac1.8%
distribute-neg-frac1.8%
add-sqr-sqrt1.8%
sqrt-unprod1.8%
sqr-neg1.8%
sqrt-unprod0.0%
add-sqr-sqrt80.8%
frac-2neg80.8%
clear-num80.7%
remove-double-div80.7%
Applied egg-rr80.7%
if -2.2499999999999999e-263 < l < 5.5Initial program 91.1%
Taylor expanded in l around 0 91.1%
unpow291.1%
times-frac99.5%
Simplified99.5%
Taylor expanded in l around 0 91.0%
unpow291.0%
Simplified91.0%
Final simplification94.8%
(FPCore (F l)
:precision binary64
(if (<= l -5.1e-45)
(* PI l)
(if (<= l 2.85e-303)
(* PI (/ (/ l F) (- F)))
(if (<= l 2.7e-196)
(* PI l)
(if (<= l 9e-175)
(* (* PI l) (- (pow F -2.0)))
(if (or (<= l 2e-98) (not (<= l 5e-5)))
(* PI l)
(/ (* PI (- l)) (* F F))))))))
double code(double F, double l) {
double tmp;
if (l <= -5.1e-45) {
tmp = ((double) M_PI) * l;
} else if (l <= 2.85e-303) {
tmp = ((double) M_PI) * ((l / F) / -F);
} else if (l <= 2.7e-196) {
tmp = ((double) M_PI) * l;
} else if (l <= 9e-175) {
tmp = (((double) M_PI) * l) * -pow(F, -2.0);
} else if ((l <= 2e-98) || !(l <= 5e-5)) {
tmp = ((double) M_PI) * l;
} else {
tmp = (((double) M_PI) * -l) / (F * F);
}
return tmp;
}
public static double code(double F, double l) {
double tmp;
if (l <= -5.1e-45) {
tmp = Math.PI * l;
} else if (l <= 2.85e-303) {
tmp = Math.PI * ((l / F) / -F);
} else if (l <= 2.7e-196) {
tmp = Math.PI * l;
} else if (l <= 9e-175) {
tmp = (Math.PI * l) * -Math.pow(F, -2.0);
} else if ((l <= 2e-98) || !(l <= 5e-5)) {
tmp = Math.PI * l;
} else {
tmp = (Math.PI * -l) / (F * F);
}
return tmp;
}
def code(F, l): tmp = 0 if l <= -5.1e-45: tmp = math.pi * l elif l <= 2.85e-303: tmp = math.pi * ((l / F) / -F) elif l <= 2.7e-196: tmp = math.pi * l elif l <= 9e-175: tmp = (math.pi * l) * -math.pow(F, -2.0) elif (l <= 2e-98) or not (l <= 5e-5): tmp = math.pi * l else: tmp = (math.pi * -l) / (F * F) return tmp
function code(F, l) tmp = 0.0 if (l <= -5.1e-45) tmp = Float64(pi * l); elseif (l <= 2.85e-303) tmp = Float64(pi * Float64(Float64(l / F) / Float64(-F))); elseif (l <= 2.7e-196) tmp = Float64(pi * l); elseif (l <= 9e-175) tmp = Float64(Float64(pi * l) * Float64(-(F ^ -2.0))); elseif ((l <= 2e-98) || !(l <= 5e-5)) tmp = Float64(pi * l); else tmp = Float64(Float64(pi * Float64(-l)) / Float64(F * F)); end return tmp end
function tmp_2 = code(F, l) tmp = 0.0; if (l <= -5.1e-45) tmp = pi * l; elseif (l <= 2.85e-303) tmp = pi * ((l / F) / -F); elseif (l <= 2.7e-196) tmp = pi * l; elseif (l <= 9e-175) tmp = (pi * l) * -(F ^ -2.0); elseif ((l <= 2e-98) || ~((l <= 5e-5))) tmp = pi * l; else tmp = (pi * -l) / (F * F); end tmp_2 = tmp; end
code[F_, l_] := If[LessEqual[l, -5.1e-45], N[(Pi * l), $MachinePrecision], If[LessEqual[l, 2.85e-303], N[(Pi * N[(N[(l / F), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, 2.7e-196], N[(Pi * l), $MachinePrecision], If[LessEqual[l, 9e-175], N[(N[(Pi * l), $MachinePrecision] * (-N[Power[F, -2.0], $MachinePrecision])), $MachinePrecision], If[Or[LessEqual[l, 2e-98], N[Not[LessEqual[l, 5e-5]], $MachinePrecision]], N[(Pi * l), $MachinePrecision], N[(N[(Pi * (-l)), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -5.1 \cdot 10^{-45}:\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{elif}\;\ell \leq 2.85 \cdot 10^{-303}:\\
\;\;\;\;\pi \cdot \frac{\frac{\ell}{F}}{-F}\\
\mathbf{elif}\;\ell \leq 2.7 \cdot 10^{-196}:\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{elif}\;\ell \leq 9 \cdot 10^{-175}:\\
\;\;\;\;\left(\pi \cdot \ell\right) \cdot \left(-{F}^{-2}\right)\\
\mathbf{elif}\;\ell \leq 2 \cdot 10^{-98} \lor \neg \left(\ell \leq 5 \cdot 10^{-5}\right):\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{else}:\\
\;\;\;\;\frac{\pi \cdot \left(-\ell\right)}{F \cdot F}\\
\end{array}
\end{array}
if l < -5.0999999999999997e-45 or 2.84999999999999991e-303 < l < 2.69999999999999982e-196 or 8.99999999999999996e-175 < l < 1.99999999999999988e-98 or 5.00000000000000024e-5 < l Initial program 71.0%
Taylor expanded in l around 0 57.5%
unpow257.5%
times-frac59.5%
Simplified59.5%
Taylor expanded in F around inf 92.3%
if -5.0999999999999997e-45 < l < 2.84999999999999991e-303Initial program 74.8%
Taylor expanded in l around 0 75.6%
unpow275.6%
times-frac99.3%
Simplified99.3%
Taylor expanded in F around 0 39.8%
unpow239.8%
associate-*r/39.8%
mul-1-neg39.8%
distribute-rgt-neg-out39.8%
Simplified39.8%
associate-/l*39.6%
associate-/r/39.8%
associate-/l/63.7%
add-sqr-sqrt0.0%
sqrt-unprod3.0%
sqr-neg3.0%
sqrt-unprod3.0%
add-sqr-sqrt3.0%
associate-/r/3.0%
frac-2neg3.0%
associate-/r/3.0%
add-sqr-sqrt0.0%
sqrt-unprod63.7%
sqr-neg63.7%
sqrt-unprod63.2%
add-sqr-sqrt63.7%
Applied egg-rr63.7%
if 2.69999999999999982e-196 < l < 8.99999999999999996e-175Initial program 99.8%
Taylor expanded in l around 0 100.0%
unpow2100.0%
times-frac99.6%
Simplified99.6%
Taylor expanded in F around 0 84.1%
mul-1-neg84.1%
unpow284.1%
*-commutative84.1%
times-frac83.9%
distribute-rgt-neg-in83.9%
distribute-frac-neg83.9%
*-commutative83.9%
distribute-frac-neg83.9%
distribute-lft-neg-in83.9%
*-rgt-identity83.9%
associate-*r/83.4%
associate-*r*83.3%
associate-*l/84.1%
associate-*r/83.9%
*-rgt-identity83.9%
associate-*r/83.5%
associate-*r*83.8%
*-commutative83.8%
associate-*r*83.7%
unpow-183.7%
unpow-183.7%
Simplified84.1%
if 1.99999999999999988e-98 < l < 5.00000000000000024e-5Initial program 99.6%
Taylor expanded in l around 0 99.8%
unpow299.8%
times-frac99.3%
Simplified99.3%
Taylor expanded in F around 0 70.0%
unpow270.0%
associate-*r/70.0%
mul-1-neg70.0%
distribute-rgt-neg-out70.0%
Simplified70.0%
Final simplification85.4%
(FPCore (F l) :precision binary64 (if (or (<= l -2.65e+17) (not (<= l 5.5))) (* PI l) (- (* PI l) (* (/ l F) (/ PI F)))))
double code(double F, double l) {
double tmp;
if ((l <= -2.65e+17) || !(l <= 5.5)) {
tmp = ((double) M_PI) * l;
} else {
tmp = (((double) M_PI) * l) - ((l / F) * (((double) M_PI) / F));
}
return tmp;
}
public static double code(double F, double l) {
double tmp;
if ((l <= -2.65e+17) || !(l <= 5.5)) {
tmp = Math.PI * l;
} else {
tmp = (Math.PI * l) - ((l / F) * (Math.PI / F));
}
return tmp;
}
def code(F, l): tmp = 0 if (l <= -2.65e+17) or not (l <= 5.5): tmp = math.pi * l else: tmp = (math.pi * l) - ((l / F) * (math.pi / F)) return tmp
function code(F, l) tmp = 0.0 if ((l <= -2.65e+17) || !(l <= 5.5)) tmp = Float64(pi * l); else tmp = Float64(Float64(pi * l) - Float64(Float64(l / F) * Float64(pi / F))); end return tmp end
function tmp_2 = code(F, l) tmp = 0.0; if ((l <= -2.65e+17) || ~((l <= 5.5))) tmp = pi * l; else tmp = (pi * l) - ((l / F) * (pi / F)); end tmp_2 = tmp; end
code[F_, l_] := If[Or[LessEqual[l, -2.65e+17], N[Not[LessEqual[l, 5.5]], $MachinePrecision]], N[(Pi * l), $MachinePrecision], N[(N[(Pi * l), $MachinePrecision] - N[(N[(l / F), $MachinePrecision] * N[(Pi / F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -2.65 \cdot 10^{+17} \lor \neg \left(\ell \leq 5.5\right):\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot \ell - \frac{\ell}{F} \cdot \frac{\pi}{F}\\
\end{array}
\end{array}
if l < -2.65e17 or 5.5 < l Initial program 63.8%
Taylor expanded in l around 0 45.7%
unpow245.7%
times-frac45.7%
Simplified45.7%
Taylor expanded in F around inf 98.8%
if -2.65e17 < l < 5.5Initial program 86.0%
Taylor expanded in l around 0 86.4%
unpow286.4%
times-frac99.4%
Simplified99.4%
Final simplification99.1%
(FPCore (F l)
:precision binary64
(if (or (<= l -4.2e-45)
(not
(or (<= l 2.1e-303)
(and (not (<= l 2.1e-196))
(or (<= l 3e-175)
(and (not (<= l 7e-101)) (<= l 1.8e-13)))))))
(* PI l)
(* (/ PI F) (- (/ l F)))))
double code(double F, double l) {
double tmp;
if ((l <= -4.2e-45) || !((l <= 2.1e-303) || (!(l <= 2.1e-196) && ((l <= 3e-175) || (!(l <= 7e-101) && (l <= 1.8e-13)))))) {
tmp = ((double) M_PI) * l;
} else {
tmp = (((double) M_PI) / F) * -(l / F);
}
return tmp;
}
public static double code(double F, double l) {
double tmp;
if ((l <= -4.2e-45) || !((l <= 2.1e-303) || (!(l <= 2.1e-196) && ((l <= 3e-175) || (!(l <= 7e-101) && (l <= 1.8e-13)))))) {
tmp = Math.PI * l;
} else {
tmp = (Math.PI / F) * -(l / F);
}
return tmp;
}
def code(F, l): tmp = 0 if (l <= -4.2e-45) or not ((l <= 2.1e-303) or (not (l <= 2.1e-196) and ((l <= 3e-175) or (not (l <= 7e-101) and (l <= 1.8e-13))))): tmp = math.pi * l else: tmp = (math.pi / F) * -(l / F) return tmp
function code(F, l) tmp = 0.0 if ((l <= -4.2e-45) || !((l <= 2.1e-303) || (!(l <= 2.1e-196) && ((l <= 3e-175) || (!(l <= 7e-101) && (l <= 1.8e-13)))))) tmp = Float64(pi * l); else tmp = Float64(Float64(pi / F) * Float64(-Float64(l / F))); end return tmp end
function tmp_2 = code(F, l) tmp = 0.0; if ((l <= -4.2e-45) || ~(((l <= 2.1e-303) || (~((l <= 2.1e-196)) && ((l <= 3e-175) || (~((l <= 7e-101)) && (l <= 1.8e-13))))))) tmp = pi * l; else tmp = (pi / F) * -(l / F); end tmp_2 = tmp; end
code[F_, l_] := If[Or[LessEqual[l, -4.2e-45], N[Not[Or[LessEqual[l, 2.1e-303], And[N[Not[LessEqual[l, 2.1e-196]], $MachinePrecision], Or[LessEqual[l, 3e-175], And[N[Not[LessEqual[l, 7e-101]], $MachinePrecision], LessEqual[l, 1.8e-13]]]]]], $MachinePrecision]], N[(Pi * l), $MachinePrecision], N[(N[(Pi / F), $MachinePrecision] * (-N[(l / F), $MachinePrecision])), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -4.2 \cdot 10^{-45} \lor \neg \left(\ell \leq 2.1 \cdot 10^{-303} \lor \neg \left(\ell \leq 2.1 \cdot 10^{-196}\right) \land \left(\ell \leq 3 \cdot 10^{-175} \lor \neg \left(\ell \leq 7 \cdot 10^{-101}\right) \land \ell \leq 1.8 \cdot 10^{-13}\right)\right):\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{else}:\\
\;\;\;\;\frac{\pi}{F} \cdot \left(-\frac{\ell}{F}\right)\\
\end{array}
\end{array}
if l < -4.1999999999999999e-45 or 2.1e-303 < l < 2.09999999999999988e-196 or 3e-175 < l < 6.99999999999999989e-101 or 1.7999999999999999e-13 < l Initial program 71.0%
Taylor expanded in l around 0 57.5%
unpow257.5%
times-frac59.5%
Simplified59.5%
Taylor expanded in F around inf 92.3%
if -4.1999999999999999e-45 < l < 2.1e-303 or 2.09999999999999988e-196 < l < 3e-175 or 6.99999999999999989e-101 < l < 1.7999999999999999e-13Initial program 82.0%
Taylor expanded in l around 0 82.6%
unpow282.6%
times-frac99.4%
Simplified99.4%
Taylor expanded in F around 0 50.0%
unpow250.0%
associate-*r/50.0%
mul-1-neg50.0%
distribute-rgt-neg-out50.0%
Simplified50.0%
associate-/l*49.8%
associate-/r/49.9%
associate-/l/66.9%
add-sqr-sqrt0.0%
sqrt-unprod2.7%
sqr-neg2.7%
sqrt-unprod2.7%
add-sqr-sqrt2.7%
associate-/r/2.7%
frac-2neg2.7%
div-inv2.7%
distribute-neg-frac2.7%
distribute-neg-frac2.7%
add-sqr-sqrt2.7%
sqrt-unprod2.7%
sqr-neg2.7%
sqrt-unprod0.0%
add-sqr-sqrt66.8%
frac-2neg66.8%
clear-num66.7%
remove-double-div66.7%
Applied egg-rr66.7%
Final simplification85.4%
(FPCore (F l)
:precision binary64
(if (<= l -6.4e-45)
(* PI l)
(if (<= l 7e-304)
(* PI (/ (/ l F) (- F)))
(if (or (<= l 3.5e-197)
(not
(or (<= l 1.4e-174) (and (not (<= l 4.5e-100)) (<= l 2.7e-7)))))
(* PI l)
(/ (* PI (- l)) (* F F))))))
double code(double F, double l) {
double tmp;
if (l <= -6.4e-45) {
tmp = ((double) M_PI) * l;
} else if (l <= 7e-304) {
tmp = ((double) M_PI) * ((l / F) / -F);
} else if ((l <= 3.5e-197) || !((l <= 1.4e-174) || (!(l <= 4.5e-100) && (l <= 2.7e-7)))) {
tmp = ((double) M_PI) * l;
} else {
tmp = (((double) M_PI) * -l) / (F * F);
}
return tmp;
}
public static double code(double F, double l) {
double tmp;
if (l <= -6.4e-45) {
tmp = Math.PI * l;
} else if (l <= 7e-304) {
tmp = Math.PI * ((l / F) / -F);
} else if ((l <= 3.5e-197) || !((l <= 1.4e-174) || (!(l <= 4.5e-100) && (l <= 2.7e-7)))) {
tmp = Math.PI * l;
} else {
tmp = (Math.PI * -l) / (F * F);
}
return tmp;
}
def code(F, l): tmp = 0 if l <= -6.4e-45: tmp = math.pi * l elif l <= 7e-304: tmp = math.pi * ((l / F) / -F) elif (l <= 3.5e-197) or not ((l <= 1.4e-174) or (not (l <= 4.5e-100) and (l <= 2.7e-7))): tmp = math.pi * l else: tmp = (math.pi * -l) / (F * F) return tmp
function code(F, l) tmp = 0.0 if (l <= -6.4e-45) tmp = Float64(pi * l); elseif (l <= 7e-304) tmp = Float64(pi * Float64(Float64(l / F) / Float64(-F))); elseif ((l <= 3.5e-197) || !((l <= 1.4e-174) || (!(l <= 4.5e-100) && (l <= 2.7e-7)))) tmp = Float64(pi * l); else tmp = Float64(Float64(pi * Float64(-l)) / Float64(F * F)); end return tmp end
function tmp_2 = code(F, l) tmp = 0.0; if (l <= -6.4e-45) tmp = pi * l; elseif (l <= 7e-304) tmp = pi * ((l / F) / -F); elseif ((l <= 3.5e-197) || ~(((l <= 1.4e-174) || (~((l <= 4.5e-100)) && (l <= 2.7e-7))))) tmp = pi * l; else tmp = (pi * -l) / (F * F); end tmp_2 = tmp; end
code[F_, l_] := If[LessEqual[l, -6.4e-45], N[(Pi * l), $MachinePrecision], If[LessEqual[l, 7e-304], N[(Pi * N[(N[(l / F), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[l, 3.5e-197], N[Not[Or[LessEqual[l, 1.4e-174], And[N[Not[LessEqual[l, 4.5e-100]], $MachinePrecision], LessEqual[l, 2.7e-7]]]], $MachinePrecision]], N[(Pi * l), $MachinePrecision], N[(N[(Pi * (-l)), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq -6.4 \cdot 10^{-45}:\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{elif}\;\ell \leq 7 \cdot 10^{-304}:\\
\;\;\;\;\pi \cdot \frac{\frac{\ell}{F}}{-F}\\
\mathbf{elif}\;\ell \leq 3.5 \cdot 10^{-197} \lor \neg \left(\ell \leq 1.4 \cdot 10^{-174} \lor \neg \left(\ell \leq 4.5 \cdot 10^{-100}\right) \land \ell \leq 2.7 \cdot 10^{-7}\right):\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{else}:\\
\;\;\;\;\frac{\pi \cdot \left(-\ell\right)}{F \cdot F}\\
\end{array}
\end{array}
if l < -6.40000000000000015e-45 or 7e-304 < l < 3.4999999999999998e-197 or 1.39999999999999999e-174 < l < 4.5000000000000001e-100 or 2.70000000000000009e-7 < l Initial program 71.0%
Taylor expanded in l around 0 57.5%
unpow257.5%
times-frac59.5%
Simplified59.5%
Taylor expanded in F around inf 92.3%
if -6.40000000000000015e-45 < l < 7e-304Initial program 74.8%
Taylor expanded in l around 0 75.6%
unpow275.6%
times-frac99.3%
Simplified99.3%
Taylor expanded in F around 0 39.8%
unpow239.8%
associate-*r/39.8%
mul-1-neg39.8%
distribute-rgt-neg-out39.8%
Simplified39.8%
associate-/l*39.6%
associate-/r/39.8%
associate-/l/63.7%
add-sqr-sqrt0.0%
sqrt-unprod3.0%
sqr-neg3.0%
sqrt-unprod3.0%
add-sqr-sqrt3.0%
associate-/r/3.0%
frac-2neg3.0%
associate-/r/3.0%
add-sqr-sqrt0.0%
sqrt-unprod63.7%
sqr-neg63.7%
sqrt-unprod63.2%
add-sqr-sqrt63.7%
Applied egg-rr63.7%
if 3.4999999999999998e-197 < l < 1.39999999999999999e-174 or 4.5000000000000001e-100 < l < 2.70000000000000009e-7Initial program 99.7%
Taylor expanded in l around 0 99.8%
unpow299.8%
times-frac99.4%
Simplified99.4%
Taylor expanded in F around 0 74.9%
unpow274.9%
associate-*r/74.9%
mul-1-neg74.9%
distribute-rgt-neg-out74.9%
Simplified74.9%
Final simplification85.4%
(FPCore (F l)
:precision binary64
(let* ((t_0 (* PI (/ (/ l F) (- F)))))
(if (<= l -9e-45)
(* PI l)
(if (<= l 1.8e-303)
t_0
(if (<= l 3e-195)
(* PI l)
(if (<= l 3.4e-175)
(* (/ PI F) (- (/ l F)))
(if (or (<= l 6.8e-99) (not (<= l 6.4e-9))) (* PI l) t_0)))))))
double code(double F, double l) {
double t_0 = ((double) M_PI) * ((l / F) / -F);
double tmp;
if (l <= -9e-45) {
tmp = ((double) M_PI) * l;
} else if (l <= 1.8e-303) {
tmp = t_0;
} else if (l <= 3e-195) {
tmp = ((double) M_PI) * l;
} else if (l <= 3.4e-175) {
tmp = (((double) M_PI) / F) * -(l / F);
} else if ((l <= 6.8e-99) || !(l <= 6.4e-9)) {
tmp = ((double) M_PI) * l;
} else {
tmp = t_0;
}
return tmp;
}
public static double code(double F, double l) {
double t_0 = Math.PI * ((l / F) / -F);
double tmp;
if (l <= -9e-45) {
tmp = Math.PI * l;
} else if (l <= 1.8e-303) {
tmp = t_0;
} else if (l <= 3e-195) {
tmp = Math.PI * l;
} else if (l <= 3.4e-175) {
tmp = (Math.PI / F) * -(l / F);
} else if ((l <= 6.8e-99) || !(l <= 6.4e-9)) {
tmp = Math.PI * l;
} else {
tmp = t_0;
}
return tmp;
}
def code(F, l): t_0 = math.pi * ((l / F) / -F) tmp = 0 if l <= -9e-45: tmp = math.pi * l elif l <= 1.8e-303: tmp = t_0 elif l <= 3e-195: tmp = math.pi * l elif l <= 3.4e-175: tmp = (math.pi / F) * -(l / F) elif (l <= 6.8e-99) or not (l <= 6.4e-9): tmp = math.pi * l else: tmp = t_0 return tmp
function code(F, l) t_0 = Float64(pi * Float64(Float64(l / F) / Float64(-F))) tmp = 0.0 if (l <= -9e-45) tmp = Float64(pi * l); elseif (l <= 1.8e-303) tmp = t_0; elseif (l <= 3e-195) tmp = Float64(pi * l); elseif (l <= 3.4e-175) tmp = Float64(Float64(pi / F) * Float64(-Float64(l / F))); elseif ((l <= 6.8e-99) || !(l <= 6.4e-9)) tmp = Float64(pi * l); else tmp = t_0; end return tmp end
function tmp_2 = code(F, l) t_0 = pi * ((l / F) / -F); tmp = 0.0; if (l <= -9e-45) tmp = pi * l; elseif (l <= 1.8e-303) tmp = t_0; elseif (l <= 3e-195) tmp = pi * l; elseif (l <= 3.4e-175) tmp = (pi / F) * -(l / F); elseif ((l <= 6.8e-99) || ~((l <= 6.4e-9))) tmp = pi * l; else tmp = t_0; end tmp_2 = tmp; end
code[F_, l_] := Block[{t$95$0 = N[(Pi * N[(N[(l / F), $MachinePrecision] / (-F)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -9e-45], N[(Pi * l), $MachinePrecision], If[LessEqual[l, 1.8e-303], t$95$0, If[LessEqual[l, 3e-195], N[(Pi * l), $MachinePrecision], If[LessEqual[l, 3.4e-175], N[(N[(Pi / F), $MachinePrecision] * (-N[(l / F), $MachinePrecision])), $MachinePrecision], If[Or[LessEqual[l, 6.8e-99], N[Not[LessEqual[l, 6.4e-9]], $MachinePrecision]], N[(Pi * l), $MachinePrecision], t$95$0]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{\frac{\ell}{F}}{-F}\\
\mathbf{if}\;\ell \leq -9 \cdot 10^{-45}:\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{elif}\;\ell \leq 1.8 \cdot 10^{-303}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;\ell \leq 3 \cdot 10^{-195}:\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{elif}\;\ell \leq 3.4 \cdot 10^{-175}:\\
\;\;\;\;\frac{\pi}{F} \cdot \left(-\frac{\ell}{F}\right)\\
\mathbf{elif}\;\ell \leq 6.8 \cdot 10^{-99} \lor \neg \left(\ell \leq 6.4 \cdot 10^{-9}\right):\\
\;\;\;\;\pi \cdot \ell\\
\mathbf{else}:\\
\;\;\;\;t_0\\
\end{array}
\end{array}
if l < -8.9999999999999997e-45 or 1.7999999999999999e-303 < l < 3e-195 or 3.4e-175 < l < 6.80000000000000014e-99 or 6.40000000000000023e-9 < l Initial program 71.0%
Taylor expanded in l around 0 57.5%
unpow257.5%
times-frac59.5%
Simplified59.5%
Taylor expanded in F around inf 92.3%
if -8.9999999999999997e-45 < l < 1.7999999999999999e-303 or 6.80000000000000014e-99 < l < 6.40000000000000023e-9Initial program 80.0%
Taylor expanded in l around 0 80.7%
unpow280.7%
times-frac99.3%
Simplified99.3%
Taylor expanded in F around 0 46.1%
unpow246.1%
associate-*r/46.1%
mul-1-neg46.1%
distribute-rgt-neg-out46.1%
Simplified46.1%
associate-/l*46.0%
associate-/r/46.1%
associate-/l/64.9%
add-sqr-sqrt0.0%
sqrt-unprod2.8%
sqr-neg2.8%
sqrt-unprod2.8%
add-sqr-sqrt2.8%
associate-/r/2.8%
frac-2neg2.8%
associate-/r/2.8%
add-sqr-sqrt0.0%
sqrt-unprod64.9%
sqr-neg64.9%
sqrt-unprod64.5%
add-sqr-sqrt64.9%
Applied egg-rr64.9%
if 3e-195 < l < 3.4e-175Initial program 99.8%
Taylor expanded in l around 0 100.0%
unpow2100.0%
times-frac99.6%
Simplified99.6%
Taylor expanded in F around 0 84.1%
unpow284.1%
associate-*r/84.1%
mul-1-neg84.1%
distribute-rgt-neg-out84.1%
Simplified84.1%
associate-/l*83.8%
associate-/r/83.7%
associate-/l/83.9%
add-sqr-sqrt0.0%
sqrt-unprod2.5%
sqr-neg2.5%
sqrt-unprod2.5%
add-sqr-sqrt2.5%
associate-/r/2.5%
frac-2neg2.5%
div-inv2.5%
distribute-neg-frac2.5%
distribute-neg-frac2.5%
add-sqr-sqrt2.5%
sqrt-unprod2.5%
sqr-neg2.5%
sqrt-unprod0.0%
add-sqr-sqrt83.9%
frac-2neg83.9%
clear-num83.9%
remove-double-div83.9%
Applied egg-rr83.9%
Final simplification85.4%
(FPCore (F l) :precision binary64 (* PI l))
double code(double F, double l) {
return ((double) M_PI) * l;
}
public static double code(double F, double l) {
return Math.PI * l;
}
def code(F, l): return math.pi * l
function code(F, l) return Float64(pi * l) end
function tmp = code(F, l) tmp = pi * l; end
code[F_, l_] := N[(Pi * l), $MachinePrecision]
\begin{array}{l}
\\
\pi \cdot \ell
\end{array}
Initial program 74.0%
Taylor expanded in l around 0 64.3%
unpow264.3%
times-frac70.2%
Simplified70.2%
Taylor expanded in F around inf 76.7%
Final simplification76.7%
herbie shell --seed 2023274
(FPCore (F l)
:name "VandenBroeck and Keller, Equation (6)"
:precision binary64
(- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))