
(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 9 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 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 2e+14)
(+
(* PI l_m)
(/
(/ (* (sin (expm1 (log1p (* PI l_m)))) (/ -1.0 (cos (* 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) <= 2e+14) {
tmp = (((double) M_PI) * l_m) + (((sin(expm1(log1p((((double) M_PI) * l_m)))) * (-1.0 / cos((((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) <= 2e+14) {
tmp = (Math.PI * l_m) + (((Math.sin(Math.expm1(Math.log1p((Math.PI * l_m)))) * (-1.0 / Math.cos((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) <= 2e+14: tmp = (math.pi * l_m) + (((math.sin(math.expm1(math.log1p((math.pi * l_m)))) * (-1.0 / math.cos((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) <= 2e+14) tmp = Float64(Float64(pi * l_m) + Float64(Float64(Float64(sin(expm1(log1p(Float64(pi * l_m)))) * Float64(-1.0 / cos(Float64(pi * l_m)))) / F) / F)); else tmp = Float64(pi * l_m); end return Float64(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], 2e+14], N[(N[(Pi * l$95$m), $MachinePrecision] + N[(N[(N[(N[Sin[N[(Exp[N[Log[1 + N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Cos[N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision]), $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 2 \cdot 10^{+14}:\\
\;\;\;\;\pi \cdot l\_m + \frac{\frac{\sin \left(\mathsf{expm1}\left(\mathsf{log1p}\left(\pi \cdot l\_m\right)\right)\right) \cdot \frac{-1}{\cos \left(\pi \cdot l\_m\right)}}{F}}{F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l\_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 2e14Initial program 81.6%
associate-*l/82.1%
*-un-lft-identity82.1%
associate-/r*87.7%
Applied egg-rr87.7%
tan-quot87.7%
div-inv87.7%
Applied egg-rr87.7%
expm1-log1p-u67.9%
Applied egg-rr67.9%
if 2e14 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification74.7%
l\_m = (fabs.f64 l)
l\_s = (copysign.f64 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 2e+14)
(- (* PI l_m) (/ (/ (log1p (expm1 (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) <= 2e+14) {
tmp = (((double) M_PI) * l_m) - ((log1p(expm1(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) <= 2e+14) {
tmp = (Math.PI * l_m) - ((Math.log1p(Math.expm1(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) <= 2e+14: tmp = (math.pi * l_m) - ((math.log1p(math.expm1(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) <= 2e+14) tmp = Float64(Float64(pi * l_m) - Float64(Float64(log1p(expm1(tan(Float64(pi * l_m)))) / F) / F)); else tmp = Float64(pi * l_m); end return Float64(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], 2e+14], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(N[Log[1 + N[(Exp[N[Tan[N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision]] - 1), $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 2 \cdot 10^{+14}:\\
\;\;\;\;\pi \cdot l\_m - \frac{\frac{\mathsf{log1p}\left(\mathsf{expm1}\left(\tan \left(\pi \cdot l\_m\right)\right)\right)}{F}}{F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l\_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 2e14Initial program 81.6%
associate-*l/82.1%
*-un-lft-identity82.1%
associate-/r*87.7%
Applied egg-rr87.7%
log1p-expm1-u87.2%
Applied egg-rr87.2%
if 2e14 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification89.8%
l\_m = (fabs.f64 l)
l\_s = (copysign.f64 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 2e+14)
(+ (* PI l_m) (/ (/ (* (sin (* PI l_m)) (/ -1.0 (cos (* 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) <= 2e+14) {
tmp = (((double) M_PI) * l_m) + (((sin((((double) M_PI) * l_m)) * (-1.0 / cos((((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) <= 2e+14) {
tmp = (Math.PI * l_m) + (((Math.sin((Math.PI * l_m)) * (-1.0 / Math.cos((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) <= 2e+14: tmp = (math.pi * l_m) + (((math.sin((math.pi * l_m)) * (-1.0 / math.cos((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) <= 2e+14) tmp = Float64(Float64(pi * l_m) + Float64(Float64(Float64(sin(Float64(pi * l_m)) * Float64(-1.0 / cos(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) <= 2e+14) tmp = (pi * l_m) + (((sin((pi * l_m)) * (-1.0 / cos((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], 2e+14], N[(N[(Pi * l$95$m), $MachinePrecision] + N[(N[(N[(N[Sin[N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Cos[N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision]), $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 2 \cdot 10^{+14}:\\
\;\;\;\;\pi \cdot l\_m + \frac{\frac{\sin \left(\pi \cdot l\_m\right) \cdot \frac{-1}{\cos \left(\pi \cdot l\_m\right)}}{F}}{F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l\_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 2e14Initial program 81.6%
associate-*l/82.1%
*-un-lft-identity82.1%
associate-/r*87.7%
Applied egg-rr87.7%
tan-quot87.7%
div-inv87.7%
Applied egg-rr87.7%
if 2e14 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification90.2%
l\_m = (fabs.f64 l)
l\_s = (copysign.f64 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 2e-135)
(- (* PI l_m) (/ (/ (* PI l_m) F) F))
(if (<= (* PI l_m) 2e+14)
(- (* 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) <= 2e-135) {
tmp = (((double) M_PI) * l_m) - (((((double) M_PI) * l_m) / F) / F);
} else if ((((double) M_PI) * l_m) <= 2e+14) {
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) <= 2e-135) {
tmp = (Math.PI * l_m) - (((Math.PI * l_m) / F) / F);
} else if ((Math.PI * l_m) <= 2e+14) {
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) <= 2e-135: tmp = (math.pi * l_m) - (((math.pi * l_m) / F) / F) elif (math.pi * l_m) <= 2e+14: 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) <= 2e-135) tmp = Float64(Float64(pi * l_m) - Float64(Float64(Float64(pi * l_m) / F) / F)); elseif (Float64(pi * l_m) <= 2e+14) tmp = Float64(Float64(pi * l_m) - Float64(tan(Float64(pi * l_m)) / Float64(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) <= 2e-135) tmp = (pi * l_m) - (((pi * l_m) / F) / F); elseif ((pi * l_m) <= 2e+14) 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], 2e-135], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(N[(Pi * l$95$m), $MachinePrecision] / F), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(Pi * l$95$m), $MachinePrecision], 2e+14], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[Tan[N[(Pi * l$95$m), $MachinePrecision]], $MachinePrecision] / N[(F * 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 2 \cdot 10^{-135}:\\
\;\;\;\;\pi \cdot l\_m - \frac{\frac{\pi \cdot l\_m}{F}}{F}\\
\mathbf{elif}\;\pi \cdot l\_m \leq 2 \cdot 10^{+14}:\\
\;\;\;\;\pi \cdot l\_m - \frac{\tan \left(\pi \cdot l\_m\right)}{F \cdot F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l\_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 2.0000000000000001e-135Initial program 78.8%
associate-*l/79.4%
*-un-lft-identity79.4%
associate-/r*85.8%
Applied egg-rr85.8%
Taylor expanded in l around 0 81.9%
if 2.0000000000000001e-135 < (*.f64 (PI.f64) l) < 2e14Initial program 99.5%
*-commutative99.5%
sqr-neg99.5%
associate-*r/99.5%
sqr-neg99.5%
*-rgt-identity99.5%
Simplified99.5%
if 2e14 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification87.5%
l\_m = (fabs.f64 l)
l\_s = (copysign.f64 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 2e+14)
(- (* 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) <= 2e+14) {
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) <= 2e+14) {
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) <= 2e+14: 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) <= 2e+14) 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) <= 2e+14) 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], 2e+14], 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 2 \cdot 10^{+14}:\\
\;\;\;\;\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) < 2e14Initial program 81.6%
associate-*l/82.1%
*-un-lft-identity82.1%
associate-/r*87.7%
Applied egg-rr87.7%
if 2e14 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification90.2%
l\_m = (fabs.f64 l)
l\_s = (copysign.f64 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 500000000000.0)
(- (* PI l_m) (/ (/ (* 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) <= 500000000000.0) {
tmp = (((double) M_PI) * l_m) - (((((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) <= 500000000000.0) {
tmp = (Math.PI * l_m) - (((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) <= 500000000000.0: tmp = (math.pi * l_m) - (((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) <= 500000000000.0) tmp = Float64(Float64(pi * l_m) - Float64(Float64(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) <= 500000000000.0) tmp = (pi * l_m) - (((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], 500000000000.0], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(N[(Pi * l$95$m), $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 500000000000:\\
\;\;\;\;\pi \cdot l\_m - \frac{\frac{\pi \cdot l\_m}{F}}{F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l\_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 5e11Initial program 81.6%
associate-*l/82.1%
*-un-lft-identity82.1%
associate-/r*87.7%
Applied egg-rr87.7%
Taylor expanded in l around 0 82.8%
if 5e11 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification86.4%
l\_m = (fabs.f64 l)
l\_s = (copysign.f64 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 500000000000.0)
(- (* PI l_m) (/ (* l_m (/ PI 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) <= 500000000000.0) {
tmp = (((double) M_PI) * l_m) - ((l_m * (((double) M_PI) / 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) <= 500000000000.0) {
tmp = (Math.PI * l_m) - ((l_m * (Math.PI / 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) <= 500000000000.0: tmp = (math.pi * l_m) - ((l_m * (math.pi / 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) <= 500000000000.0) tmp = Float64(Float64(pi * l_m) - Float64(Float64(l_m * Float64(pi / 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) <= 500000000000.0) tmp = (pi * l_m) - ((l_m * (pi / 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], 500000000000.0], N[(N[(Pi * l$95$m), $MachinePrecision] - N[(N[(l$95$m * N[(Pi / F), $MachinePrecision]), $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 500000000000:\\
\;\;\;\;\pi \cdot l\_m - \frac{l\_m \cdot \frac{\pi}{F}}{F}\\
\mathbf{else}:\\
\;\;\;\;\pi \cdot l\_m\\
\end{array}
\end{array}
if (*.f64 (PI.f64) l) < 5e11Initial program 81.6%
associate-*l/82.1%
*-un-lft-identity82.1%
associate-/r*87.7%
Applied egg-rr87.7%
Taylor expanded in l around 0 82.8%
associate-*r/82.8%
Simplified82.8%
if 5e11 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification86.4%
l\_m = (fabs.f64 l)
l\_s = (copysign.f64 #s(literal 1 binary64) l)
(FPCore (l_s F l_m)
:precision binary64
(*
l_s
(if (<= (* PI l_m) 500000000000.0)
(- (* 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) <= 500000000000.0) {
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) <= 500000000000.0) {
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) <= 500000000000.0: 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) <= 500000000000.0) 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) <= 500000000000.0) 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], 500000000000.0], 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 500000000000:\\
\;\;\;\;\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) < 5e11Initial program 81.6%
*-commutative81.6%
sqr-neg81.6%
associate-*r/82.1%
sqr-neg82.1%
*-rgt-identity82.1%
Simplified82.1%
Taylor expanded in l around 0 77.3%
*-commutative77.3%
times-frac82.8%
Applied egg-rr82.8%
if 5e11 < (*.f64 (PI.f64) l) Initial program 62.3%
fma-neg62.3%
distribute-lft-neg-in62.3%
sqr-neg62.3%
distribute-neg-frac262.3%
sqr-neg62.3%
distribute-rgt-neg-out62.3%
associate-*l/62.3%
*-lft-identity62.3%
Simplified62.3%
Taylor expanded in l around 0 49.0%
mul-1-neg49.0%
associate-/l*49.0%
distribute-rgt-neg-in49.0%
mul-1-neg49.0%
associate-*r/49.0%
*-commutative49.0%
associate-/l*49.0%
metadata-eval49.0%
distribute-neg-frac49.0%
unpow-149.0%
exp-to-pow27.3%
*-commutative27.3%
exp-prod27.3%
*-commutative27.3%
associate-*l*27.3%
metadata-eval27.3%
exp-to-pow49.0%
Simplified49.0%
Taylor expanded in F around inf 99.6%
Final simplification86.4%
l\_m = (fabs.f64 l) l\_s = (copysign.f64 #s(literal 1 binary64) 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 77.5%
fma-neg77.5%
distribute-lft-neg-in77.5%
sqr-neg77.5%
distribute-neg-frac277.5%
sqr-neg77.5%
distribute-rgt-neg-out77.5%
associate-*l/77.9%
*-lft-identity77.9%
Simplified77.9%
Taylor expanded in l around 0 71.2%
mul-1-neg71.2%
associate-/l*70.8%
distribute-rgt-neg-in70.8%
mul-1-neg70.8%
associate-*r/70.8%
*-commutative70.8%
associate-/l*70.8%
metadata-eval70.8%
distribute-neg-frac70.8%
unpow-170.8%
exp-to-pow34.0%
*-commutative34.0%
exp-prod34.0%
*-commutative34.0%
associate-*l*34.0%
metadata-eval34.0%
exp-to-pow70.8%
Simplified70.8%
Taylor expanded in F around inf 73.4%
Final simplification73.4%
herbie shell --seed 2024108
(FPCore (F l)
:name "VandenBroeck and Keller, Equation (6)"
:precision binary64
(- (* PI l) (* (/ 1.0 (* F F)) (tan (* PI l)))))