
(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 8 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}
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 2000000000000.0)
(- (* PI l_m) (/ (/ (tan (* PI l_m)) F) F))
(* PI l_m))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((((double) M_PI) * l_m) <= 2000000000000.0) {
tmp = (((double) M_PI) * l_m) - ((tan((((double) M_PI) * l_m)) / F) / F);
} else {
tmp = ((double) M_PI) * l_m;
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if ((Math.PI * l_m) <= 2000000000000.0) {
tmp = (Math.PI * l_m) - ((Math.tan((Math.PI * l_m)) / F) / F);
} else {
tmp = Math.PI * l_m;
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if (math.pi * l_m) <= 2000000000000.0: tmp = (math.pi * l_m) - ((math.tan((math.pi * l_m)) / F) / F) else: tmp = math.pi * l_m return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (Float64(pi * l_m) <= 2000000000000.0) tmp = Float64(Float64(pi * l_m) - Float64(Float64(tan(Float64(pi * l_m)) / F) / F)); else tmp = Float64(pi * l_m); end return Float64(l_s * tmp) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp_2 = code(l_s, F, l_m) tmp = 0.0; if ((pi * l_m) <= 2000000000000.0) tmp = (pi * l_m) - ((tan((pi * l_m)) / F) / F); else tmp = pi * l_m; end tmp_2 = l_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 2000000000000.0], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(N[Tan[N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision] / F), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision], N[(Pi * l$95$m), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;\pi \cdot l_m \leq 2000000000000:\\
\;\;\;\;\pi \cdot l_m - \frac{\frac{\tan \left(\pi \cdot l_m\right)}{F}}{F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 2e12Initial program 80.6%
associate-*l/81.0%
*-un-lft-identity81.0%
associate-/r*84.8%
Applied egg-rr84.8%
if 2e12 < (*.f64 (PI.f64) l) Initial program 57.9%
sqr-neg57.9%
associate-*l/57.9%
sqr-neg57.9%
*-lft-identity57.9%
Simplified57.9%
Taylor expanded in l around 0 41.9%
Taylor expanded in F around inf 99.7%
Final simplification88.0%
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 7.2e-241)
(* PI l_m)
(if (<= (* PI l_m) 5e-136)
(/ (/ (* l_m (- PI)) F) F)
(if (or (<= (* PI l_m) 1e-94) (not (<= (* PI l_m) 2e-61)))
(* PI l_m)
(* (/ l_m (pow F 2.0)) (- PI)))))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((((double) M_PI) * l_m) <= 7.2e-241) {
tmp = ((double) M_PI) * l_m;
} else if ((((double) M_PI) * l_m) <= 5e-136) {
tmp = ((l_m * -((double) M_PI)) / F) / F;
} else if (((((double) M_PI) * l_m) <= 1e-94) || !((((double) M_PI) * l_m) <= 2e-61)) {
tmp = ((double) M_PI) * l_m;
} else {
tmp = (l_m / pow(F, 2.0)) * -((double) M_PI);
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if ((Math.PI * l_m) <= 7.2e-241) {
tmp = Math.PI * l_m;
} else if ((Math.PI * l_m) <= 5e-136) {
tmp = ((l_m * -Math.PI) / F) / F;
} else if (((Math.PI * l_m) <= 1e-94) || !((Math.PI * l_m) <= 2e-61)) {
tmp = Math.PI * l_m;
} else {
tmp = (l_m / Math.pow(F, 2.0)) * -Math.PI;
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if (math.pi * l_m) <= 7.2e-241: tmp = math.pi * l_m elif (math.pi * l_m) <= 5e-136: tmp = ((l_m * -math.pi) / F) / F elif ((math.pi * l_m) <= 1e-94) or not ((math.pi * l_m) <= 2e-61): tmp = math.pi * l_m else: tmp = (l_m / math.pow(F, 2.0)) * -math.pi return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (Float64(pi * l_m) <= 7.2e-241) tmp = Float64(pi * l_m); elseif (Float64(pi * l_m) <= 5e-136) tmp = Float64(Float64(Float64(l_m * Float64(-pi)) / F) / F); elseif ((Float64(pi * l_m) <= 1e-94) || !(Float64(pi * l_m) <= 2e-61)) tmp = Float64(pi * l_m); else tmp = Float64(Float64(l_m / (F ^ 2.0)) * Float64(-pi)); end return Float64(l_s * tmp) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp_2 = code(l_s, F, l_m) tmp = 0.0; if ((pi * l_m) <= 7.2e-241) tmp = pi * l_m; elseif ((pi * l_m) <= 5e-136) tmp = ((l_m * -pi) / F) / F; elseif (((pi * l_m) <= 1e-94) || ~(((pi * l_m) <= 2e-61))) tmp = pi * l_m; else tmp = (l_m / (F ^ 2.0)) * -pi; end tmp_2 = l_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 7.2e-241], N[(Pi * l$95$m), $MachinePrecision], If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 5e-136], N[(N[(N[(l$95$m * (-Pi)), $MachinePrecision] / F), $MachinePrecision] / F), $MachinePrecision], If[Or[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 1e-94], N[Not[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 2e-61]], $MachinePrecision]], N[(Pi * l$95$m), $MachinePrecision], N[(N[(l$95$m / N[Power[F, 2.0], $MachinePrecision]), $MachinePrecision] * (-Pi)), $MachinePrecision]]]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;\pi \cdot l_m \leq 7.2 \cdot 10^{-241}:\\
\;\;\;\;\pi \cdot l_m\\
\mathbf{elif}\;\pi \cdot l_m \leq 5 \cdot 10^{-136}:\\
\;\;\;\;\frac{\frac{l_m \cdot \left(-\pi\right)}{F}}{F}\\
\mathbf{elif}\;\pi \cdot l_m \leq 10^{-94} \lor \neg \left(\pi \cdot l_m \leq 2 \cdot 10^{-61}\right):\\
\;\;\;\;\pi \cdot l_m\\
\mathbf{else}:\\
\;\;\;\;\frac{l_m}{{F}^{2}} \cdot \left(-\pi\right)\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 7.1999999999999998e-241 or 5.0000000000000002e-136 < (*.f64 (PI.f64) l) < 9.9999999999999996e-95 or 2.0000000000000001e-61 < (*.f64 (PI.f64) l) Initial program 74.0%
sqr-neg74.0%
associate-*l/74.0%
sqr-neg74.0%
*-lft-identity74.0%
Simplified74.0%
Taylor expanded in l around 0 63.9%
Taylor expanded in F around inf 80.9%
if 7.1999999999999998e-241 < (*.f64 (PI.f64) l) < 5.0000000000000002e-136Initial program 90.5%
sqr-neg90.5%
associate-*l/94.5%
sqr-neg94.5%
*-lft-identity94.5%
Simplified94.5%
Taylor expanded in l around 0 94.5%
Taylor expanded in F around 0 57.8%
mul-1-neg57.8%
associate-*l/57.9%
*-commutative57.9%
Simplified57.9%
associate-*r/57.8%
unpow257.8%
associate-/r*62.9%
Applied egg-rr62.9%
if 9.9999999999999996e-95 < (*.f64 (PI.f64) l) < 2.0000000000000001e-61Initial program 99.6%
sqr-neg99.6%
associate-*l/99.2%
sqr-neg99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in l around 0 99.2%
Taylor expanded in F around 0 75.5%
mul-1-neg75.5%
associate-*l/75.5%
*-commutative75.5%
Simplified75.5%
Final simplification79.3%
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 7.2e-241)
(* PI l_m)
(if (<= (* PI l_m) 5e-136)
(/ (/ (* l_m (- PI)) F) F)
(if (or (<= (* PI l_m) 1e-94) (not (<= (* PI l_m) 2e-61)))
(* PI l_m)
(/ (* (/ l_m F) (- PI)) F))))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((((double) M_PI) * l_m) <= 7.2e-241) {
tmp = ((double) M_PI) * l_m;
} else if ((((double) M_PI) * l_m) <= 5e-136) {
tmp = ((l_m * -((double) M_PI)) / F) / F;
} else if (((((double) M_PI) * l_m) <= 1e-94) || !((((double) M_PI) * l_m) <= 2e-61)) {
tmp = ((double) M_PI) * l_m;
} else {
tmp = ((l_m / F) * -((double) M_PI)) / F;
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if ((Math.PI * l_m) <= 7.2e-241) {
tmp = Math.PI * l_m;
} else if ((Math.PI * l_m) <= 5e-136) {
tmp = ((l_m * -Math.PI) / F) / F;
} else if (((Math.PI * l_m) <= 1e-94) || !((Math.PI * l_m) <= 2e-61)) {
tmp = Math.PI * l_m;
} else {
tmp = ((l_m / F) * -Math.PI) / F;
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if (math.pi * l_m) <= 7.2e-241: tmp = math.pi * l_m elif (math.pi * l_m) <= 5e-136: tmp = ((l_m * -math.pi) / F) / F elif ((math.pi * l_m) <= 1e-94) or not ((math.pi * l_m) <= 2e-61): tmp = math.pi * l_m else: tmp = ((l_m / F) * -math.pi) / F return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (Float64(pi * l_m) <= 7.2e-241) tmp = Float64(pi * l_m); elseif (Float64(pi * l_m) <= 5e-136) tmp = Float64(Float64(Float64(l_m * Float64(-pi)) / F) / F); elseif ((Float64(pi * l_m) <= 1e-94) || !(Float64(pi * l_m) <= 2e-61)) tmp = Float64(pi * l_m); else tmp = Float64(Float64(Float64(l_m / F) * Float64(-pi)) / F); end return Float64(l_s * tmp) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp_2 = code(l_s, F, l_m) tmp = 0.0; if ((pi * l_m) <= 7.2e-241) tmp = pi * l_m; elseif ((pi * l_m) <= 5e-136) tmp = ((l_m * -pi) / F) / F; elseif (((pi * l_m) <= 1e-94) || ~(((pi * l_m) <= 2e-61))) tmp = pi * l_m; else tmp = ((l_m / F) * -pi) / F; end tmp_2 = l_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 7.2e-241], N[(Pi * l$95$m), $MachinePrecision], If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 5e-136], N[(N[(N[(l$95$m * (-Pi)), $MachinePrecision] / F), $MachinePrecision] / F), $MachinePrecision], If[Or[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 1e-94], N[Not[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 2e-61]], $MachinePrecision]], N[(Pi * l$95$m), $MachinePrecision], N[(N[(N[(l$95$m / F), $MachinePrecision] * (-Pi)), $MachinePrecision] / F), $MachinePrecision]]]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;\pi \cdot l_m \leq 7.2 \cdot 10^{-241}:\\
\;\;\;\;\pi \cdot l_m\\
\mathbf{elif}\;\pi \cdot l_m \leq 5 \cdot 10^{-136}:\\
\;\;\;\;\frac{\frac{l_m \cdot \left(-\pi\right)}{F}}{F}\\
\mathbf{elif}\;\pi \cdot l_m \leq 10^{-94} \lor \neg \left(\pi \cdot l_m \leq 2 \cdot 10^{-61}\right):\\
\;\;\;\;\pi \cdot l_m\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{l_m}{F} \cdot \left(-\pi\right)}{F}\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 7.1999999999999998e-241 or 5.0000000000000002e-136 < (*.f64 (PI.f64) l) < 9.9999999999999996e-95 or 2.0000000000000001e-61 < (*.f64 (PI.f64) l) Initial program 74.0%
sqr-neg74.0%
associate-*l/74.0%
sqr-neg74.0%
*-lft-identity74.0%
Simplified74.0%
Taylor expanded in l around 0 63.9%
Taylor expanded in F around inf 80.9%
if 7.1999999999999998e-241 < (*.f64 (PI.f64) l) < 5.0000000000000002e-136Initial program 90.5%
sqr-neg90.5%
associate-*l/94.5%
sqr-neg94.5%
*-lft-identity94.5%
Simplified94.5%
Taylor expanded in l around 0 94.5%
Taylor expanded in F around 0 57.8%
mul-1-neg57.8%
associate-*l/57.9%
*-commutative57.9%
Simplified57.9%
associate-*r/57.8%
unpow257.8%
associate-/r*62.9%
Applied egg-rr62.9%
if 9.9999999999999996e-95 < (*.f64 (PI.f64) l) < 2.0000000000000001e-61Initial program 99.6%
sqr-neg99.6%
associate-*l/99.2%
sqr-neg99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in l around 0 99.2%
Taylor expanded in F around 0 75.5%
mul-1-neg75.5%
associate-*l/75.5%
*-commutative75.5%
Simplified75.5%
associate-*r/75.5%
unpow275.5%
frac-times75.9%
associate-*l/75.1%
Applied egg-rr75.1%
Final simplification79.3%
l_m = (fabs.f64 l) l_s = (copysign.f64 1 l) (FPCore (l_s F l_m) :precision binary64 (* l_s (if (<= (* PI l_m) 8e-15) (- (* PI l_m) (* (/ PI F) (/ l_m F))) (* PI l_m))))
l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((((double) M_PI) * l_m) <= 8e-15) {
tmp = (((double) M_PI) * l_m) - ((((double) M_PI) / F) * (l_m / F));
} else {
tmp = ((double) M_PI) * l_m;
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if ((Math.PI * l_m) <= 8e-15) {
tmp = (Math.PI * l_m) - ((Math.PI / F) * (l_m / F));
} else {
tmp = Math.PI * l_m;
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if (math.pi * l_m) <= 8e-15: tmp = (math.pi * l_m) - ((math.pi / F) * (l_m / F)) else: tmp = math.pi * l_m return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (Float64(pi * l_m) <= 8e-15) tmp = Float64(Float64(pi * l_m) - Float64(Float64(pi / F) * Float64(l_m / F))); else tmp = Float64(pi * l_m); end return Float64(l_s * tmp) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp_2 = code(l_s, F, l_m) tmp = 0.0; if ((pi * l_m) <= 8e-15) tmp = (pi * l_m) - ((pi / F) * (l_m / F)); else tmp = pi * l_m; end tmp_2 = l_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 8e-15], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(Pi / F), $MachinePrecision] * N[(l$95$m / F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(Pi * l$95$m), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;\pi \cdot l_m \leq 8 \cdot 10^{-15}:\\
\;\;\;\;\pi \cdot l_m - \frac{\pi}{F} \cdot \frac{l_m}{F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 8.0000000000000006e-15Initial program 79.8%
sqr-neg79.8%
associate-*l/80.2%
sqr-neg80.2%
*-lft-identity80.2%
Simplified80.2%
Taylor expanded in l around 0 73.3%
*-commutative73.3%
times-frac77.7%
Applied egg-rr77.7%
if 8.0000000000000006e-15 < (*.f64 (PI.f64) l) Initial program 63.2%
sqr-neg63.2%
associate-*l/63.2%
sqr-neg63.2%
*-lft-identity63.2%
Simplified63.2%
Taylor expanded in l around 0 47.7%
Taylor expanded in F around inf 98.1%
Final simplification82.7%
l_m = (fabs.f64 l) l_s = (copysign.f64 1 l) (FPCore (l_s F l_m) :precision binary64 (* l_s (if (<= (* PI l_m) 8e-15) (* (* PI l_m) (- 1.0 (pow F -2.0))) (* PI l_m))))
l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((((double) M_PI) * l_m) <= 8e-15) {
tmp = (((double) M_PI) * l_m) * (1.0 - pow(F, -2.0));
} else {
tmp = ((double) M_PI) * l_m;
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if ((Math.PI * l_m) <= 8e-15) {
tmp = (Math.PI * l_m) * (1.0 - Math.pow(F, -2.0));
} else {
tmp = Math.PI * l_m;
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if (math.pi * l_m) <= 8e-15: tmp = (math.pi * l_m) * (1.0 - math.pow(F, -2.0)) else: tmp = math.pi * l_m return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (Float64(pi * l_m) <= 8e-15) tmp = Float64(Float64(pi * l_m) * Float64(1.0 - (F ^ -2.0))); else tmp = Float64(pi * l_m); end return Float64(l_s * tmp) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp_2 = code(l_s, F, l_m) tmp = 0.0; if ((pi * l_m) <= 8e-15) tmp = (pi * l_m) * (1.0 - (F ^ -2.0)); else tmp = pi * l_m; end tmp_2 = l_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 8e-15], N[(N[(Pi * l$95$m), $MachinePrecision] * N[(1.0 - N[Power[F, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(Pi * l$95$m), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;\pi \cdot l_m \leq 8 \cdot 10^{-15}:\\
\;\;\;\;\left(\pi \cdot l_m\right) \cdot \left(1 - {F}^{-2}\right)\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 8.0000000000000006e-15Initial program 79.8%
sqr-neg79.8%
associate-*l/80.2%
sqr-neg80.2%
*-lft-identity80.2%
Simplified80.2%
Taylor expanded in l around 0 73.3%
Taylor expanded in l around 0 73.3%
*-lft-identity73.3%
associate-*l/73.3%
unpow273.3%
associate-/r*73.4%
*-rgt-identity73.4%
associate-*r/73.3%
unpow-173.3%
unpow-173.3%
pow-sqr73.4%
metadata-eval73.4%
*-commutative73.4%
distribute-lft-out--73.4%
*-commutative73.4%
associate-*r*72.9%
*-commutative72.9%
*-rgt-identity72.9%
distribute-lft-out--73.4%
Simplified73.4%
if 8.0000000000000006e-15 < (*.f64 (PI.f64) l) Initial program 63.2%
sqr-neg63.2%
associate-*l/63.2%
sqr-neg63.2%
*-lft-identity63.2%
Simplified63.2%
Taylor expanded in l around 0 47.7%
Taylor expanded in F around inf 98.1%
Final simplification79.5%
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (or (<= l_m 2.26e-241)
(not
(or (<= l_m 7.5e-136) (and (not (<= l_m 4.2e-93)) (<= l_m 9e-60)))))
(* PI l_m)
(/ (* (/ l_m F) (- PI)) F))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if ((l_m <= 2.26e-241) || !((l_m <= 7.5e-136) || (!(l_m <= 4.2e-93) && (l_m <= 9e-60)))) {
tmp = ((double) M_PI) * l_m;
} else {
tmp = ((l_m / F) * -((double) M_PI)) / F;
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if ((l_m <= 2.26e-241) || !((l_m <= 7.5e-136) || (!(l_m <= 4.2e-93) && (l_m <= 9e-60)))) {
tmp = Math.PI * l_m;
} else {
tmp = ((l_m / F) * -Math.PI) / F;
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if (l_m <= 2.26e-241) or not ((l_m <= 7.5e-136) or (not (l_m <= 4.2e-93) and (l_m <= 9e-60))): tmp = math.pi * l_m else: tmp = ((l_m / F) * -math.pi) / F return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if ((l_m <= 2.26e-241) || !((l_m <= 7.5e-136) || (!(l_m <= 4.2e-93) && (l_m <= 9e-60)))) tmp = Float64(pi * l_m); else tmp = Float64(Float64(Float64(l_m / F) * Float64(-pi)) / F); end return Float64(l_s * tmp) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp_2 = code(l_s, F, l_m) tmp = 0.0; if ((l_m <= 2.26e-241) || ~(((l_m <= 7.5e-136) || (~((l_m <= 4.2e-93)) && (l_m <= 9e-60))))) tmp = pi * l_m; else tmp = ((l_m / F) * -pi) / F; end tmp_2 = l_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[Or[LessEqual[l$95$m, 2.26e-241], N[Not[Or[LessEqual[l$95$m, 7.5e-136], And[N[Not[LessEqual[l$95$m, 4.2e-93]], $MachinePrecision], LessEqual[l$95$m, 9e-60]]]], $MachinePrecision]], N[(Pi * l$95$m), $MachinePrecision], N[(N[(N[(l$95$m / F), $MachinePrecision] * (-Pi)), $MachinePrecision] / F), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;l_m \leq 2.26 \cdot 10^{-241} \lor \neg \left(l_m \leq 7.5 \cdot 10^{-136} \lor \neg \left(l_m \leq 4.2 \cdot 10^{-93}\right) \land l_m \leq 9 \cdot 10^{-60}\right):\\
\;\;\;\;\pi \cdot l_m\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{l_m}{F} \cdot \left(-\pi\right)}{F}\\
\end{array}
\end{array}
if l < 2.26e-241 or 7.5000000000000003e-136 < l < 4.2000000000000002e-93 or 9.00000000000000001e-60 < l Initial program 74.0%
sqr-neg74.0%
associate-*l/74.0%
sqr-neg74.0%
*-lft-identity74.0%
Simplified74.0%
Taylor expanded in l around 0 63.9%
Taylor expanded in F around inf 80.9%
if 2.26e-241 < l < 7.5000000000000003e-136 or 4.2000000000000002e-93 < l < 9.00000000000000001e-60Initial program 91.9%
sqr-neg91.9%
associate-*l/95.3%
sqr-neg95.3%
*-lft-identity95.3%
Simplified95.3%
Taylor expanded in l around 0 95.3%
Taylor expanded in F around 0 60.6%
mul-1-neg60.6%
associate-*l/60.7%
*-commutative60.7%
Simplified60.7%
associate-*r/60.6%
unpow260.6%
frac-times65.1%
associate-*l/64.9%
Applied egg-rr64.9%
Final simplification79.3%
l_m = (fabs.f64 l)
l_s = (copysign.f64 1 l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= l_m 2.26e-241)
(* PI l_m)
(if (<= l_m 2.45e-136)
(/ (* l_m (/ (- PI) F)) F)
(if (or (<= l_m 2.55e-89) (not (<= l_m 2.9e-54)))
(* PI l_m)
(/ (* (/ l_m F) (- PI)) F))))))l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
double tmp;
if (l_m <= 2.26e-241) {
tmp = ((double) M_PI) * l_m;
} else if (l_m <= 2.45e-136) {
tmp = (l_m * (-((double) M_PI) / F)) / F;
} else if ((l_m <= 2.55e-89) || !(l_m <= 2.9e-54)) {
tmp = ((double) M_PI) * l_m;
} else {
tmp = ((l_m / F) * -((double) M_PI)) / F;
}
return l_s * tmp;
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
double tmp;
if (l_m <= 2.26e-241) {
tmp = Math.PI * l_m;
} else if (l_m <= 2.45e-136) {
tmp = (l_m * (-Math.PI / F)) / F;
} else if ((l_m <= 2.55e-89) || !(l_m <= 2.9e-54)) {
tmp = Math.PI * l_m;
} else {
tmp = ((l_m / F) * -Math.PI) / F;
}
return l_s * tmp;
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): tmp = 0 if l_m <= 2.26e-241: tmp = math.pi * l_m elif l_m <= 2.45e-136: tmp = (l_m * (-math.pi / F)) / F elif (l_m <= 2.55e-89) or not (l_m <= 2.9e-54): tmp = math.pi * l_m else: tmp = ((l_m / F) * -math.pi) / F return l_s * tmp
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) tmp = 0.0 if (l_m <= 2.26e-241) tmp = Float64(pi * l_m); elseif (l_m <= 2.45e-136) tmp = Float64(Float64(l_m * Float64(Float64(-pi) / F)) / F); elseif ((l_m <= 2.55e-89) || !(l_m <= 2.9e-54)) tmp = Float64(pi * l_m); else tmp = Float64(Float64(Float64(l_m / F) * Float64(-pi)) / F); end return Float64(l_s * tmp) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp_2 = code(l_s, F, l_m) tmp = 0.0; if (l_m <= 2.26e-241) tmp = pi * l_m; elseif (l_m <= 2.45e-136) tmp = (l_m * (-pi / F)) / F; elseif ((l_m <= 2.55e-89) || ~((l_m <= 2.9e-54))) tmp = pi * l_m; else tmp = ((l_m / F) * -pi) / F; end tmp_2 = l_s * tmp; end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * If[LessEqual[l$95$m, 2.26e-241], N[(Pi * l$95$m), $MachinePrecision], If[LessEqual[l$95$m, 2.45e-136], N[(N[(l$95$m * N[((-Pi) / F), $MachinePrecision]), $MachinePrecision] / F), $MachinePrecision], If[Or[LessEqual[l$95$m, 2.55e-89], N[Not[LessEqual[l$95$m, 2.9e-54]], $MachinePrecision]], N[(Pi * l$95$m), $MachinePrecision], N[(N[(N[(l$95$m / F), $MachinePrecision] * (-Pi)), $MachinePrecision] / F), $MachinePrecision]]]]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \begin{array}{l}
\mathbf{if}\;l_m \leq 2.26 \cdot 10^{-241}:\\
\;\;\;\;\pi \cdot l_m\\
\mathbf{elif}\;l_m \leq 2.45 \cdot 10^{-136}:\\
\;\;\;\;\frac{l_m \cdot \frac{-\pi}{F}}{F}\\
\mathbf{elif}\;l_m \leq 2.55 \cdot 10^{-89} \lor \neg \left(l_m \leq 2.9 \cdot 10^{-54}\right):\\
\;\;\;\;\pi \cdot l_m\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{l_m}{F} \cdot \left(-\pi\right)}{F}\\
\end{array}
\end{array}
if l < 2.26e-241 or 2.45e-136 < l < 2.55000000000000002e-89 or 2.90000000000000015e-54 < l Initial program 74.0%
sqr-neg74.0%
associate-*l/74.0%
sqr-neg74.0%
*-lft-identity74.0%
Simplified74.0%
Taylor expanded in l around 0 63.9%
Taylor expanded in F around inf 80.9%
if 2.26e-241 < l < 2.45e-136Initial program 90.5%
sqr-neg90.5%
associate-*l/94.5%
sqr-neg94.5%
*-lft-identity94.5%
Simplified94.5%
Taylor expanded in l around 0 94.5%
Taylor expanded in F around 0 57.8%
mul-1-neg57.8%
associate-*l/57.9%
*-commutative57.9%
Simplified57.9%
associate-*r/57.8%
unpow257.8%
frac-times63.0%
associate-*r/63.1%
Applied egg-rr63.1%
if 2.55000000000000002e-89 < l < 2.90000000000000015e-54Initial program 99.6%
sqr-neg99.6%
associate-*l/99.2%
sqr-neg99.2%
*-lft-identity99.2%
Simplified99.2%
Taylor expanded in l around 0 99.2%
Taylor expanded in F around 0 75.5%
mul-1-neg75.5%
associate-*l/75.5%
*-commutative75.5%
Simplified75.5%
associate-*r/75.5%
unpow275.5%
frac-times75.9%
associate-*l/75.1%
Applied egg-rr75.1%
Final simplification79.3%
l_m = (fabs.f64 l) l_s = (copysign.f64 1 l) (FPCore (l_s F l_m) :precision binary64 (* l_s (* PI l_m)))
l_m = fabs(l);
l_s = copysign(1.0, l);
double code(double l_s, double F, double l_m) {
return l_s * (((double) M_PI) * l_m);
}
l_m = Math.abs(l);
l_s = Math.copySign(1.0, l);
public static double code(double l_s, double F, double l_m) {
return l_s * (Math.PI * l_m);
}
l_m = math.fabs(l) l_s = math.copysign(1.0, l) def code(l_s, F, l_m): return l_s * (math.pi * l_m)
l_m = abs(l) l_s = copysign(1.0, l) function code(l_s, F, l_m) return Float64(l_s * Float64(pi * l_m)) end
l_m = abs(l); l_s = sign(l) * abs(1.0); function tmp = code(l_s, F, l_m) tmp = l_s * (pi * l_m); end
l_m = N[Abs[l], $MachinePrecision]
l_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[l]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[l$95$s_, F_, l$95$m_] := N[(l$95$s * N[(Pi * l$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
l_m = \left|\ell\right|
\\
l_s = \mathsf{copysign}\left(1, \ell\right)
\\
l_s \cdot \left(\pi \cdot l_m\right)
\end{array}
Initial program 75.7%
sqr-neg75.7%
associate-*l/76.0%
sqr-neg76.0%
*-lft-identity76.0%
Simplified76.0%
Taylor expanded in l around 0 67.0%
Taylor expanded in F around inf 76.2%
Final simplification76.2%
herbie shell --seed 2023334
(FPCore (F l)
:name "VandenBroeck and Keller, Equation (6)"
:precision binary64
(- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))