
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 21 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
\end{array}
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0 (/ PI (/ 180.0 angle_m)))
(t_1
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m))))))
(*
angle_s
(if (<= a_m 1.85e-126)
(*
(+ b a_m)
(*
t_1
(* (- b a_m) (cos (* (sqrt PI) (* (/ angle_m 180.0) (sqrt PI)))))))
(if (<= a_m 2e+157)
(*
(+ b a_m)
(*
(* (- b a_m) (cos t_0))
(*
2.0
(sin
(/
(-
(* 180.0 (* (/ angle_m 180.0) (+ -1.0 (* PI PI))))
(* angle_m (+ -1.0 PI)))
(* 180.0 (+ -1.0 PI)))))))
(* (+ b a_m) (* t_1 (* (- b a_m) (cos (exp (log t_0)))))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = ((double) M_PI) / (180.0 / angle_m);
double t_1 = 2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)));
double tmp;
if (a_m <= 1.85e-126) {
tmp = (b + a_m) * (t_1 * ((b - a_m) * cos((sqrt(((double) M_PI)) * ((angle_m / 180.0) * sqrt(((double) M_PI)))))));
} else if (a_m <= 2e+157) {
tmp = (b + a_m) * (((b - a_m) * cos(t_0)) * (2.0 * sin((((180.0 * ((angle_m / 180.0) * (-1.0 + (((double) M_PI) * ((double) M_PI))))) - (angle_m * (-1.0 + ((double) M_PI)))) / (180.0 * (-1.0 + ((double) M_PI)))))));
} else {
tmp = (b + a_m) * (t_1 * ((b - a_m) * cos(exp(log(t_0)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = Math.PI / (180.0 / angle_m);
double t_1 = 2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)));
double tmp;
if (a_m <= 1.85e-126) {
tmp = (b + a_m) * (t_1 * ((b - a_m) * Math.cos((Math.sqrt(Math.PI) * ((angle_m / 180.0) * Math.sqrt(Math.PI))))));
} else if (a_m <= 2e+157) {
tmp = (b + a_m) * (((b - a_m) * Math.cos(t_0)) * (2.0 * Math.sin((((180.0 * ((angle_m / 180.0) * (-1.0 + (Math.PI * Math.PI)))) - (angle_m * (-1.0 + Math.PI))) / (180.0 * (-1.0 + Math.PI))))));
} else {
tmp = (b + a_m) * (t_1 * ((b - a_m) * Math.cos(Math.exp(Math.log(t_0)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = math.pi / (180.0 / angle_m) t_1 = 2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))) tmp = 0 if a_m <= 1.85e-126: tmp = (b + a_m) * (t_1 * ((b - a_m) * math.cos((math.sqrt(math.pi) * ((angle_m / 180.0) * math.sqrt(math.pi)))))) elif a_m <= 2e+157: tmp = (b + a_m) * (((b - a_m) * math.cos(t_0)) * (2.0 * math.sin((((180.0 * ((angle_m / 180.0) * (-1.0 + (math.pi * math.pi)))) - (angle_m * (-1.0 + math.pi))) / (180.0 * (-1.0 + math.pi)))))) else: tmp = (b + a_m) * (t_1 * ((b - a_m) * math.cos(math.exp(math.log(t_0))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(pi / Float64(180.0 / angle_m)) t_1 = Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))) tmp = 0.0 if (a_m <= 1.85e-126) tmp = Float64(Float64(b + a_m) * Float64(t_1 * Float64(Float64(b - a_m) * cos(Float64(sqrt(pi) * Float64(Float64(angle_m / 180.0) * sqrt(pi))))))); elseif (a_m <= 2e+157) tmp = Float64(Float64(b + a_m) * Float64(Float64(Float64(b - a_m) * cos(t_0)) * Float64(2.0 * sin(Float64(Float64(Float64(180.0 * Float64(Float64(angle_m / 180.0) * Float64(-1.0 + Float64(pi * pi)))) - Float64(angle_m * Float64(-1.0 + pi))) / Float64(180.0 * Float64(-1.0 + pi))))))); else tmp = Float64(Float64(b + a_m) * Float64(t_1 * Float64(Float64(b - a_m) * cos(exp(log(t_0)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = pi / (180.0 / angle_m); t_1 = 2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))); tmp = 0.0; if (a_m <= 1.85e-126) tmp = (b + a_m) * (t_1 * ((b - a_m) * cos((sqrt(pi) * ((angle_m / 180.0) * sqrt(pi)))))); elseif (a_m <= 2e+157) tmp = (b + a_m) * (((b - a_m) * cos(t_0)) * (2.0 * sin((((180.0 * ((angle_m / 180.0) * (-1.0 + (pi * pi)))) - (angle_m * (-1.0 + pi))) / (180.0 * (-1.0 + pi)))))); else tmp = (b + a_m) * (t_1 * ((b - a_m) * cos(exp(log(t_0))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[a$95$m, 1.85e-126], N[(N[(b + a$95$m), $MachinePrecision] * N[(t$95$1 * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(N[Sqrt[Pi], $MachinePrecision] * N[(N[(angle$95$m / 180.0), $MachinePrecision] * N[Sqrt[Pi], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a$95$m, 2e+157], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(180.0 * N[(N[(angle$95$m / 180.0), $MachinePrecision] * N[(-1.0 + N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(angle$95$m * N[(-1.0 + Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(180.0 * N[(-1.0 + Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(t$95$1 * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[Exp[N[Log[t$95$0], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \frac{\pi}{\frac{180}{angle\_m}}\\
t_1 := 2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 1.85 \cdot 10^{-126}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(t\_1 \cdot \left(\left(b - a\_m\right) \cdot \cos \left(\sqrt{\pi} \cdot \left(\frac{angle\_m}{180} \cdot \sqrt{\pi}\right)\right)\right)\right)\\
\mathbf{elif}\;a\_m \leq 2 \cdot 10^{+157}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(\left(b - a\_m\right) \cdot \cos t\_0\right) \cdot \left(2 \cdot \sin \left(\frac{180 \cdot \left(\frac{angle\_m}{180} \cdot \left(-1 + \pi \cdot \pi\right)\right) - angle\_m \cdot \left(-1 + \pi\right)}{180 \cdot \left(-1 + \pi\right)}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(t\_1 \cdot \left(\left(b - a\_m\right) \cdot \cos \left(e^{\log t\_0}\right)\right)\right)\\
\end{array}
\end{array}
\end{array}
if a < 1.85e-126Initial program 49.6%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified50.2%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr58.6%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr58.6%
div-invN/A
add-sqr-sqrtN/A
clear-numN/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6462.3%
Applied egg-rr62.3%
if 1.85e-126 < a < 1.99999999999999997e157Initial program 50.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified49.4%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr60.1%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
clear-numN/A
div-invN/A
flip-+N/A
clear-numN/A
associate-*l/N/A
frac-subN/A
/-lowering-/.f64N/A
Applied egg-rr65.5%
if 1.99999999999999997e157 < a Initial program 46.6%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified42.0%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr77.1%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr86.3%
associate-/r/N/A
associate-*l/N/A
clear-numN/A
rem-exp-logN/A
rec-expN/A
associate-/l/N/A
neg-logN/A
clear-numN/A
associate-/r/N/A
associate-*l/N/A
exp-lowering-exp.f64N/A
associate-*l/N/A
associate-/r/N/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6454.5%
Applied egg-rr54.5%
Final simplification62.5%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(*
(+ b a_m)
(*
(*
(cos
(/ (pow (exp -1.0) (log 180.0)) (pow (exp -1.0) (log (* PI angle_m)))))
(- b a_m))
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((cos((pow(exp(-1.0), log(180.0)) / pow(exp(-1.0), log((((double) M_PI) * angle_m))))) * (b - a_m)) * (2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((Math.cos((Math.pow(Math.exp(-1.0), Math.log(180.0)) / Math.pow(Math.exp(-1.0), Math.log((Math.PI * angle_m))))) * (b - a_m)) * (2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * ((b + a_m) * ((math.cos((math.pow(math.exp(-1.0), math.log(180.0)) / math.pow(math.exp(-1.0), math.log((math.pi * angle_m))))) * (b - a_m)) * (2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(b + a_m) * Float64(Float64(cos(Float64((exp(-1.0) ^ log(180.0)) / (exp(-1.0) ^ log(Float64(pi * angle_m))))) * Float64(b - a_m)) * Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m))))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * ((b + a_m) * ((cos(((exp(-1.0) ^ log(180.0)) / (exp(-1.0) ^ log((pi * angle_m))))) * (b - a_m)) * (2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(N[Cos[N[(N[Power[N[Exp[-1.0], $MachinePrecision], N[Log[180.0], $MachinePrecision]], $MachinePrecision] / N[Power[N[Exp[-1.0], $MachinePrecision], N[Log[N[(Pi * angle$95$m), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(b + a\_m\right) \cdot \left(\left(\cos \left(\frac{{\left(e^{-1}\right)}^{\log 180}}{{\left(e^{-1}\right)}^{\log \left(\pi \cdot angle\_m\right)}}\right) \cdot \left(b - a\_m\right)\right) \cdot \left(2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\right)\right)\right)
\end{array}
Initial program 49.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified49.3%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr60.6%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr62.5%
associate-/r/N/A
associate-*l/N/A
clear-numN/A
unpow-1N/A
exp-to-powN/A
*-commutativeN/A
exp-prodN/A
log-divN/A
pow-subN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
exp-lowering-exp.f64N/A
log-lowering-log.f64N/A
pow-lowering-pow.f64N/A
exp-lowering-exp.f64N/A
log-lowering-log.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6437.8%
Applied egg-rr37.8%
Final simplification37.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(*
(+ b a_m)
(*
(*
(- b a_m)
(cos
(+
(/ (pow (exp -1.0) (log 180.0)) (pow (exp -1.0) (log (* PI angle_m))))
(+ (* angle_m -0.005555555555555556) (/ angle_m 180.0)))))
(* 2.0 (sin (/ PI (/ 180.0 angle_m))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * (((b - a_m) * cos(((pow(exp(-1.0), log(180.0)) / pow(exp(-1.0), log((((double) M_PI) * angle_m)))) + ((angle_m * -0.005555555555555556) + (angle_m / 180.0))))) * (2.0 * sin((((double) M_PI) / (180.0 / angle_m))))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * (((b - a_m) * Math.cos(((Math.pow(Math.exp(-1.0), Math.log(180.0)) / Math.pow(Math.exp(-1.0), Math.log((Math.PI * angle_m)))) + ((angle_m * -0.005555555555555556) + (angle_m / 180.0))))) * (2.0 * Math.sin((Math.PI / (180.0 / angle_m))))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * ((b + a_m) * (((b - a_m) * math.cos(((math.pow(math.exp(-1.0), math.log(180.0)) / math.pow(math.exp(-1.0), math.log((math.pi * angle_m)))) + ((angle_m * -0.005555555555555556) + (angle_m / 180.0))))) * (2.0 * math.sin((math.pi / (180.0 / angle_m))))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(b + a_m) * Float64(Float64(Float64(b - a_m) * cos(Float64(Float64((exp(-1.0) ^ log(180.0)) / (exp(-1.0) ^ log(Float64(pi * angle_m)))) + Float64(Float64(angle_m * -0.005555555555555556) + Float64(angle_m / 180.0))))) * Float64(2.0 * sin(Float64(pi / Float64(180.0 / angle_m))))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * ((b + a_m) * (((b - a_m) * cos((((exp(-1.0) ^ log(180.0)) / (exp(-1.0) ^ log((pi * angle_m)))) + ((angle_m * -0.005555555555555556) + (angle_m / 180.0))))) * (2.0 * sin((pi / (180.0 / angle_m)))))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(N[(N[Power[N[Exp[-1.0], $MachinePrecision], N[Log[180.0], $MachinePrecision]], $MachinePrecision] / N[Power[N[Exp[-1.0], $MachinePrecision], N[Log[N[(Pi * angle$95$m), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + N[(N[(angle$95$m * -0.005555555555555556), $MachinePrecision] + N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[Sin[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(b + a\_m\right) \cdot \left(\left(\left(b - a\_m\right) \cdot \cos \left(\frac{{\left(e^{-1}\right)}^{\log 180}}{{\left(e^{-1}\right)}^{\log \left(\pi \cdot angle\_m\right)}} + \left(angle\_m \cdot -0.005555555555555556 + \frac{angle\_m}{180}\right)\right)\right) \cdot \left(2 \cdot \sin \left(\frac{\pi}{\frac{180}{angle\_m}}\right)\right)\right)\right)
\end{array}
Initial program 49.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified49.3%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr60.6%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
clear-numN/A
associate-/r/N/A
div-invN/A
metadata-evalN/A
prod-diffN/A
metadata-evalN/A
associate-/r/N/A
clear-numN/A
fmm-defN/A
associate-/r/N/A
Applied egg-rr60.1%
associate-/r/N/A
associate-*l/N/A
clear-numN/A
unpow-1N/A
exp-to-powN/A
*-commutativeN/A
exp-prodN/A
log-divN/A
pow-subN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
exp-lowering-exp.f64N/A
log-lowering-log.f64N/A
pow-lowering-pow.f64N/A
exp-lowering-exp.f64N/A
log-lowering-log.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6436.7%
Applied egg-rr36.7%
Final simplification36.7%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m))))))
(*
angle_s
(if (<= a_m 8e+156)
(*
(+ b a_m)
(*
t_0
(*
(- b a_m)
(cos (* (/ (sqrt PI) 180.0) (/ (sqrt PI) (/ 1.0 angle_m)))))))
(*
(+ b a_m)
(* t_0 (* (- b a_m) (cos (exp (log (/ PI (/ 180.0 angle_m))))))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = 2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)));
double tmp;
if (a_m <= 8e+156) {
tmp = (b + a_m) * (t_0 * ((b - a_m) * cos(((sqrt(((double) M_PI)) / 180.0) * (sqrt(((double) M_PI)) / (1.0 / angle_m))))));
} else {
tmp = (b + a_m) * (t_0 * ((b - a_m) * cos(exp(log((((double) M_PI) / (180.0 / angle_m)))))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = 2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)));
double tmp;
if (a_m <= 8e+156) {
tmp = (b + a_m) * (t_0 * ((b - a_m) * Math.cos(((Math.sqrt(Math.PI) / 180.0) * (Math.sqrt(Math.PI) / (1.0 / angle_m))))));
} else {
tmp = (b + a_m) * (t_0 * ((b - a_m) * Math.cos(Math.exp(Math.log((Math.PI / (180.0 / angle_m)))))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = 2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))) tmp = 0 if a_m <= 8e+156: tmp = (b + a_m) * (t_0 * ((b - a_m) * math.cos(((math.sqrt(math.pi) / 180.0) * (math.sqrt(math.pi) / (1.0 / angle_m)))))) else: tmp = (b + a_m) * (t_0 * ((b - a_m) * math.cos(math.exp(math.log((math.pi / (180.0 / angle_m))))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))) tmp = 0.0 if (a_m <= 8e+156) tmp = Float64(Float64(b + a_m) * Float64(t_0 * Float64(Float64(b - a_m) * cos(Float64(Float64(sqrt(pi) / 180.0) * Float64(sqrt(pi) / Float64(1.0 / angle_m))))))); else tmp = Float64(Float64(b + a_m) * Float64(t_0 * Float64(Float64(b - a_m) * cos(exp(log(Float64(pi / Float64(180.0 / angle_m)))))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = 2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))); tmp = 0.0; if (a_m <= 8e+156) tmp = (b + a_m) * (t_0 * ((b - a_m) * cos(((sqrt(pi) / 180.0) * (sqrt(pi) / (1.0 / angle_m)))))); else tmp = (b + a_m) * (t_0 * ((b - a_m) * cos(exp(log((pi / (180.0 / angle_m))))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[a$95$m, 8e+156], N[(N[(b + a$95$m), $MachinePrecision] * N[(t$95$0 * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(N[(N[Sqrt[Pi], $MachinePrecision] / 180.0), $MachinePrecision] * N[(N[Sqrt[Pi], $MachinePrecision] / N[(1.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(t$95$0 * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[Exp[N[Log[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := 2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 8 \cdot 10^{+156}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(t\_0 \cdot \left(\left(b - a\_m\right) \cdot \cos \left(\frac{\sqrt{\pi}}{180} \cdot \frac{\sqrt{\pi}}{\frac{1}{angle\_m}}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(t\_0 \cdot \left(\left(b - a\_m\right) \cdot \cos \left(e^{\log \left(\frac{\pi}{\frac{180}{angle\_m}}\right)}\right)\right)\right)\\
\end{array}
\end{array}
\end{array}
if a < 7.9999999999999999e156Initial program 49.8%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified50.0%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr59.0%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr60.2%
add-sqr-sqrtN/A
div-invN/A
times-fracN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6460.9%
Applied egg-rr60.9%
if 7.9999999999999999e156 < a Initial program 46.6%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified42.0%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr77.1%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr86.3%
associate-/r/N/A
associate-*l/N/A
clear-numN/A
rem-exp-logN/A
rec-expN/A
associate-/l/N/A
neg-logN/A
clear-numN/A
associate-/r/N/A
associate-*l/N/A
exp-lowering-exp.f64N/A
associate-*l/N/A
associate-/r/N/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6454.5%
Applied egg-rr54.5%
Final simplification60.4%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(*
(+ b a_m)
(*
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m))))
(* (- b a_m) (cos (exp (log (/ PI (/ 180.0 angle_m))))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))) * ((b - a_m) * cos(exp(log((((double) M_PI) / (180.0 / angle_m))))))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((b + a_m) * ((2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))) * ((b - a_m) * Math.cos(Math.exp(Math.log((Math.PI / (180.0 / angle_m))))))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * ((b + a_m) * ((2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))) * ((b - a_m) * math.cos(math.exp(math.log((math.pi / (180.0 / angle_m))))))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(b + a_m) * Float64(Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))) * Float64(Float64(b - a_m) * cos(exp(log(Float64(pi / Float64(180.0 / angle_m))))))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * ((b + a_m) * ((2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))) * ((b - a_m) * cos(exp(log((pi / (180.0 / angle_m)))))))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[Exp[N[Log[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(b + a\_m\right) \cdot \left(\left(2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\right) \cdot \left(\left(b - a\_m\right) \cdot \cos \left(e^{\log \left(\frac{\pi}{\frac{180}{angle\_m}}\right)}\right)\right)\right)\right)
\end{array}
Initial program 49.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified49.3%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr60.6%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr62.5%
associate-/r/N/A
associate-*l/N/A
clear-numN/A
rem-exp-logN/A
rec-expN/A
associate-/l/N/A
neg-logN/A
clear-numN/A
associate-/r/N/A
associate-*l/N/A
exp-lowering-exp.f64N/A
associate-*l/N/A
associate-/r/N/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6435.5%
Applied egg-rr35.5%
Final simplification35.5%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= (/ angle_m 180.0) 5e+188)
(*
(+ b a_m)
(*
(* 2.0 (sin (/ PI (/ 180.0 angle_m))))
(* (- b a_m) (cos (exp (- 0.0 (log (/ 180.0 (* PI angle_m)))))))))
(*
(+ b a_m)
(*
(- b a_m)
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 5e+188) {
tmp = (b + a_m) * ((2.0 * sin((((double) M_PI) / (180.0 / angle_m)))) * ((b - a_m) * cos(exp((0.0 - log((180.0 / (((double) M_PI) * angle_m))))))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 5e+188) {
tmp = (b + a_m) * ((2.0 * Math.sin((Math.PI / (180.0 / angle_m)))) * ((b - a_m) * Math.cos(Math.exp((0.0 - Math.log((180.0 / (Math.PI * angle_m))))))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if (angle_m / 180.0) <= 5e+188: tmp = (b + a_m) * ((2.0 * math.sin((math.pi / (180.0 / angle_m)))) * ((b - a_m) * math.cos(math.exp((0.0 - math.log((180.0 / (math.pi * angle_m)))))))) else: tmp = (b + a_m) * ((b - a_m) * (2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 5e+188) tmp = Float64(Float64(b + a_m) * Float64(Float64(2.0 * sin(Float64(pi / Float64(180.0 / angle_m)))) * Float64(Float64(b - a_m) * cos(exp(Float64(0.0 - log(Float64(180.0 / Float64(pi * angle_m))))))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if ((angle_m / 180.0) <= 5e+188) tmp = (b + a_m) * ((2.0 * sin((pi / (180.0 / angle_m)))) * ((b - a_m) * cos(exp((0.0 - log((180.0 / (pi * angle_m)))))))); else tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 5e+188], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(2.0 * N[Sin[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[Exp[N[(0.0 - N[Log[N[(180.0 / N[(Pi * angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 5 \cdot 10^{+188}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(2 \cdot \sin \left(\frac{\pi}{\frac{180}{angle\_m}}\right)\right) \cdot \left(\left(b - a\_m\right) \cdot \cos \left(e^{0 - \log \left(\frac{180}{\pi \cdot angle\_m}\right)}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 5.0000000000000001e188Initial program 53.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified53.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr64.8%
associate-/r/N/A
associate-*l/N/A
clear-numN/A
inv-powN/A
metadata-evalN/A
pow-to-expN/A
exp-lowering-exp.f64N/A
*-lowering-*.f64N/A
log-lowering-log.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
metadata-eval37.2%
Applied egg-rr37.2%
if 5.0000000000000001e188 < (/.f64 angle #s(literal 180 binary64)) Initial program 17.2%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified13.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr25.1%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr23.7%
Taylor expanded in angle around 0
Simplified35.0%
Final simplification37.0%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0 (/ PI (/ 180.0 angle_m))))
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+165)
(*
(+ b a_m)
(*
(* (- b a_m) (cos t_0))
(*
2.0
(sin
(/
(- (* (/ 1.0 angle_m) (* (+ PI 1.0) (* 180.0 angle_m))) 180.0)
(/ 32400.0 angle_m))))))
(*
(+ b a_m)
(*
(* 2.0 (sin t_0))
(*
(- b a_m)
(cos
(/
(-
(* 180.0 (* (/ angle_m 180.0) (+ -1.0 (* PI PI))))
(* angle_m (+ -1.0 PI)))
(* 180.0 (+ -1.0 PI)))))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = ((double) M_PI) / (180.0 / angle_m);
double tmp;
if ((angle_m / 180.0) <= 2e+165) {
tmp = (b + a_m) * (((b - a_m) * cos(t_0)) * (2.0 * sin(((((1.0 / angle_m) * ((((double) M_PI) + 1.0) * (180.0 * angle_m))) - 180.0) / (32400.0 / angle_m)))));
} else {
tmp = (b + a_m) * ((2.0 * sin(t_0)) * ((b - a_m) * cos((((180.0 * ((angle_m / 180.0) * (-1.0 + (((double) M_PI) * ((double) M_PI))))) - (angle_m * (-1.0 + ((double) M_PI)))) / (180.0 * (-1.0 + ((double) M_PI)))))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = Math.PI / (180.0 / angle_m);
double tmp;
if ((angle_m / 180.0) <= 2e+165) {
tmp = (b + a_m) * (((b - a_m) * Math.cos(t_0)) * (2.0 * Math.sin(((((1.0 / angle_m) * ((Math.PI + 1.0) * (180.0 * angle_m))) - 180.0) / (32400.0 / angle_m)))));
} else {
tmp = (b + a_m) * ((2.0 * Math.sin(t_0)) * ((b - a_m) * Math.cos((((180.0 * ((angle_m / 180.0) * (-1.0 + (Math.PI * Math.PI)))) - (angle_m * (-1.0 + Math.PI))) / (180.0 * (-1.0 + Math.PI))))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = math.pi / (180.0 / angle_m) tmp = 0 if (angle_m / 180.0) <= 2e+165: tmp = (b + a_m) * (((b - a_m) * math.cos(t_0)) * (2.0 * math.sin(((((1.0 / angle_m) * ((math.pi + 1.0) * (180.0 * angle_m))) - 180.0) / (32400.0 / angle_m))))) else: tmp = (b + a_m) * ((2.0 * math.sin(t_0)) * ((b - a_m) * math.cos((((180.0 * ((angle_m / 180.0) * (-1.0 + (math.pi * math.pi)))) - (angle_m * (-1.0 + math.pi))) / (180.0 * (-1.0 + math.pi)))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(pi / Float64(180.0 / angle_m)) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+165) tmp = Float64(Float64(b + a_m) * Float64(Float64(Float64(b - a_m) * cos(t_0)) * Float64(2.0 * sin(Float64(Float64(Float64(Float64(1.0 / angle_m) * Float64(Float64(pi + 1.0) * Float64(180.0 * angle_m))) - 180.0) / Float64(32400.0 / angle_m)))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(2.0 * sin(t_0)) * Float64(Float64(b - a_m) * cos(Float64(Float64(Float64(180.0 * Float64(Float64(angle_m / 180.0) * Float64(-1.0 + Float64(pi * pi)))) - Float64(angle_m * Float64(-1.0 + pi))) / Float64(180.0 * Float64(-1.0 + pi))))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = pi / (180.0 / angle_m); tmp = 0.0; if ((angle_m / 180.0) <= 2e+165) tmp = (b + a_m) * (((b - a_m) * cos(t_0)) * (2.0 * sin(((((1.0 / angle_m) * ((pi + 1.0) * (180.0 * angle_m))) - 180.0) / (32400.0 / angle_m))))); else tmp = (b + a_m) * ((2.0 * sin(t_0)) * ((b - a_m) * cos((((180.0 * ((angle_m / 180.0) * (-1.0 + (pi * pi)))) - (angle_m * (-1.0 + pi))) / (180.0 * (-1.0 + pi)))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+165], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(N[(1.0 / angle$95$m), $MachinePrecision] * N[(N[(Pi + 1.0), $MachinePrecision] * N[(180.0 * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(2.0 * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(N[(N[(180.0 * N[(N[(angle$95$m / 180.0), $MachinePrecision] * N[(-1.0 + N[(Pi * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(angle$95$m * N[(-1.0 + Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(180.0 * N[(-1.0 + Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \frac{\pi}{\frac{180}{angle\_m}}\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+165}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(\left(b - a\_m\right) \cdot \cos t\_0\right) \cdot \left(2 \cdot \sin \left(\frac{\frac{1}{angle\_m} \cdot \left(\left(\pi + 1\right) \cdot \left(180 \cdot angle\_m\right)\right) - 180}{\frac{32400}{angle\_m}}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(2 \cdot \sin t\_0\right) \cdot \left(\left(b - a\_m\right) \cdot \cos \left(\frac{180 \cdot \left(\frac{angle\_m}{180} \cdot \left(-1 + \pi \cdot \pi\right)\right) - angle\_m \cdot \left(-1 + \pi\right)}{180 \cdot \left(-1 + \pi\right)}\right)\right)\right)\\
\end{array}
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.9999999999999998e165Initial program 54.7%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified54.9%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr65.9%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr67.8%
associate-*r/N/A
div-invN/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6467.3%
Applied egg-rr67.3%
if 1.9999999999999998e165 < (/.f64 angle #s(literal 180 binary64)) Initial program 14.7%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified11.6%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr24.7%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
clear-numN/A
div-invN/A
flip-+N/A
clear-numN/A
associate-*l/N/A
frac-subN/A
/-lowering-/.f64N/A
Applied egg-rr42.4%
Final simplification64.1%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0 (* angle_m (+ PI 1.0))))
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+196)
(*
(+ b a_m)
(*
(cos (/ PI (/ 180.0 angle_m)))
(*
(* (- b a_m) 2.0)
(sin (/ (+ (/ t_0 (/ angle_m 180.0)) -180.0) (/ 32400.0 angle_m))))))
(*
(+ b a_m)
(*
(- b a_m)
(*
2.0
(sin
(/ (- (* t_0 (/ 180.0 angle_m)) 180.0) (/ 32400.0 angle_m))))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = angle_m * (((double) M_PI) + 1.0);
double tmp;
if ((angle_m / 180.0) <= 2e+196) {
tmp = (b + a_m) * (cos((((double) M_PI) / (180.0 / angle_m))) * (((b - a_m) * 2.0) * sin((((t_0 / (angle_m / 180.0)) + -180.0) / (32400.0 / angle_m)))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * sin((((t_0 * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = angle_m * (Math.PI + 1.0);
double tmp;
if ((angle_m / 180.0) <= 2e+196) {
tmp = (b + a_m) * (Math.cos((Math.PI / (180.0 / angle_m))) * (((b - a_m) * 2.0) * Math.sin((((t_0 / (angle_m / 180.0)) + -180.0) / (32400.0 / angle_m)))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * Math.sin((((t_0 * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = angle_m * (math.pi + 1.0) tmp = 0 if (angle_m / 180.0) <= 2e+196: tmp = (b + a_m) * (math.cos((math.pi / (180.0 / angle_m))) * (((b - a_m) * 2.0) * math.sin((((t_0 / (angle_m / 180.0)) + -180.0) / (32400.0 / angle_m))))) else: tmp = (b + a_m) * ((b - a_m) * (2.0 * math.sin((((t_0 * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(angle_m * Float64(pi + 1.0)) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+196) tmp = Float64(Float64(b + a_m) * Float64(cos(Float64(pi / Float64(180.0 / angle_m))) * Float64(Float64(Float64(b - a_m) * 2.0) * sin(Float64(Float64(Float64(t_0 / Float64(angle_m / 180.0)) + -180.0) / Float64(32400.0 / angle_m)))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(Float64(Float64(t_0 * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = angle_m * (pi + 1.0); tmp = 0.0; if ((angle_m / 180.0) <= 2e+196) tmp = (b + a_m) * (cos((pi / (180.0 / angle_m))) * (((b - a_m) * 2.0) * sin((((t_0 / (angle_m / 180.0)) + -180.0) / (32400.0 / angle_m))))); else tmp = (b + a_m) * ((b - a_m) * (2.0 * sin((((t_0 * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+196], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[Cos[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[(N[(b - a$95$m), $MachinePrecision] * 2.0), $MachinePrecision] * N[Sin[N[(N[(N[(t$95$0 / N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision] + -180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(t$95$0 * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := angle\_m \cdot \left(\pi + 1\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+196}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\cos \left(\frac{\pi}{\frac{180}{angle\_m}}\right) \cdot \left(\left(\left(b - a\_m\right) \cdot 2\right) \cdot \sin \left(\frac{\frac{t\_0}{\frac{angle\_m}{180}} + -180}{\frac{32400}{angle\_m}}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(\frac{t\_0 \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\right)\right)\\
\end{array}
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.9999999999999999e196Initial program 52.9%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified53.1%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr64.3%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr67.0%
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr66.8%
if 1.9999999999999999e196 < (/.f64 angle #s(literal 180 binary64)) Initial program 17.9%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified13.9%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr26.5%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr21.0%
Taylor expanded in angle around 0
Simplified33.7%
Final simplification63.6%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+192)
(*
(+ b a_m)
(*
(*
(- b a_m)
(cos
(+
(+ (* angle_m -0.005555555555555556) (/ angle_m 180.0))
(/ PI (/ 180.0 angle_m)))))
(* 2.0 (sin (* 0.005555555555555556 (/ PI (/ 1.0 angle_m)))))))
(*
(+ b a_m)
(*
(- b a_m)
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e+192) {
tmp = (b + a_m) * (((b - a_m) * cos((((angle_m * -0.005555555555555556) + (angle_m / 180.0)) + (((double) M_PI) / (180.0 / angle_m))))) * (2.0 * sin((0.005555555555555556 * (((double) M_PI) / (1.0 / angle_m))))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e+192) {
tmp = (b + a_m) * (((b - a_m) * Math.cos((((angle_m * -0.005555555555555556) + (angle_m / 180.0)) + (Math.PI / (180.0 / angle_m))))) * (2.0 * Math.sin((0.005555555555555556 * (Math.PI / (1.0 / angle_m))))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if (angle_m / 180.0) <= 2e+192: tmp = (b + a_m) * (((b - a_m) * math.cos((((angle_m * -0.005555555555555556) + (angle_m / 180.0)) + (math.pi / (180.0 / angle_m))))) * (2.0 * math.sin((0.005555555555555556 * (math.pi / (1.0 / angle_m)))))) else: tmp = (b + a_m) * ((b - a_m) * (2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+192) tmp = Float64(Float64(b + a_m) * Float64(Float64(Float64(b - a_m) * cos(Float64(Float64(Float64(angle_m * -0.005555555555555556) + Float64(angle_m / 180.0)) + Float64(pi / Float64(180.0 / angle_m))))) * Float64(2.0 * sin(Float64(0.005555555555555556 * Float64(pi / Float64(1.0 / angle_m))))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if ((angle_m / 180.0) <= 2e+192) tmp = (b + a_m) * (((b - a_m) * cos((((angle_m * -0.005555555555555556) + (angle_m / 180.0)) + (pi / (180.0 / angle_m))))) * (2.0 * sin((0.005555555555555556 * (pi / (1.0 / angle_m)))))); else tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+192], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(N[(N[(angle$95$m * -0.005555555555555556), $MachinePrecision] + N[(angle$95$m / 180.0), $MachinePrecision]), $MachinePrecision] + N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[Sin[N[(0.005555555555555556 * N[(Pi / N[(1.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+192}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(\left(b - a\_m\right) \cdot \cos \left(\left(angle\_m \cdot -0.005555555555555556 + \frac{angle\_m}{180}\right) + \frac{\pi}{\frac{180}{angle\_m}}\right)\right) \cdot \left(2 \cdot \sin \left(0.005555555555555556 \cdot \frac{\pi}{\frac{1}{angle\_m}}\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000008e192Initial program 53.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified53.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr64.8%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
clear-numN/A
associate-/r/N/A
div-invN/A
metadata-evalN/A
prod-diffN/A
metadata-evalN/A
associate-/r/N/A
clear-numN/A
fmm-defN/A
associate-/r/N/A
Applied egg-rr64.6%
*-un-lft-identityN/A
div-invN/A
times-fracN/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
PI-lowering-PI.f64N/A
/-lowering-/.f6466.7%
Applied egg-rr66.7%
if 2.00000000000000008e192 < (/.f64 angle #s(literal 180 binary64)) Initial program 17.2%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified13.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr25.1%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr23.7%
Taylor expanded in angle around 0
Simplified35.0%
Final simplification63.3%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= (/ angle_m 180.0) 2e+192)
(*
(+ b a_m)
(*
(* (- b a_m) (cos (/ PI (/ 180.0 angle_m))))
(* 2.0 (sin (* (* PI angle_m) 0.005555555555555556)))))
(*
(+ b a_m)
(*
(- b a_m)
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e+192) {
tmp = (b + a_m) * (((b - a_m) * cos((((double) M_PI) / (180.0 / angle_m)))) * (2.0 * sin(((((double) M_PI) * angle_m) * 0.005555555555555556))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 2e+192) {
tmp = (b + a_m) * (((b - a_m) * Math.cos((Math.PI / (180.0 / angle_m)))) * (2.0 * Math.sin(((Math.PI * angle_m) * 0.005555555555555556))));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if (angle_m / 180.0) <= 2e+192: tmp = (b + a_m) * (((b - a_m) * math.cos((math.pi / (180.0 / angle_m)))) * (2.0 * math.sin(((math.pi * angle_m) * 0.005555555555555556)))) else: tmp = (b + a_m) * ((b - a_m) * (2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 2e+192) tmp = Float64(Float64(b + a_m) * Float64(Float64(Float64(b - a_m) * cos(Float64(pi / Float64(180.0 / angle_m)))) * Float64(2.0 * sin(Float64(Float64(pi * angle_m) * 0.005555555555555556))))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if ((angle_m / 180.0) <= 2e+192) tmp = (b + a_m) * (((b - a_m) * cos((pi / (180.0 / angle_m)))) * (2.0 * sin(((pi * angle_m) * 0.005555555555555556)))); else tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 2e+192], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[Cos[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(Pi * angle$95$m), $MachinePrecision] * 0.005555555555555556), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 2 \cdot 10^{+192}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(\left(b - a\_m\right) \cdot \cos \left(\frac{\pi}{\frac{180}{angle\_m}}\right)\right) \cdot \left(2 \cdot \sin \left(\left(\pi \cdot angle\_m\right) \cdot 0.005555555555555556\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2.00000000000000008e192Initial program 53.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified53.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr64.8%
associate-/r/N/A
associate-*l/N/A
div-invN/A
metadata-evalN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6466.1%
Applied egg-rr66.1%
if 2.00000000000000008e192 < (/.f64 angle #s(literal 180 binary64)) Initial program 17.2%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified13.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr25.1%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr23.7%
Taylor expanded in angle around 0
Simplified35.0%
Final simplification62.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= (/ angle_m 180.0) 1e+139)
(* (- b a_m) (* (+ b a_m) (sin (* (* PI angle_m) 0.011111111111111112))))
(*
(+ b a_m)
(*
(- b a_m)
(*
2.0
(sin
(/
(- (* (* angle_m (+ PI 1.0)) (/ 180.0 angle_m)) 180.0)
(/ 32400.0 angle_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 1e+139) {
tmp = (b - a_m) * ((b + a_m) * sin(((((double) M_PI) * angle_m) * 0.011111111111111112)));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (((double) M_PI) + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if ((angle_m / 180.0) <= 1e+139) {
tmp = (b - a_m) * ((b + a_m) * Math.sin(((Math.PI * angle_m) * 0.011111111111111112)));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * Math.sin(((((angle_m * (Math.PI + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if (angle_m / 180.0) <= 1e+139: tmp = (b - a_m) * ((b + a_m) * math.sin(((math.pi * angle_m) * 0.011111111111111112))) else: tmp = (b + a_m) * ((b - a_m) * (2.0 * math.sin(((((angle_m * (math.pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (Float64(angle_m / 180.0) <= 1e+139) tmp = Float64(Float64(b - a_m) * Float64(Float64(b + a_m) * sin(Float64(Float64(pi * angle_m) * 0.011111111111111112)))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(Float64(Float64(Float64(angle_m * Float64(pi + 1.0)) * Float64(180.0 / angle_m)) - 180.0) / Float64(32400.0 / angle_m)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if ((angle_m / 180.0) <= 1e+139) tmp = (b - a_m) * ((b + a_m) * sin(((pi * angle_m) * 0.011111111111111112))); else tmp = (b + a_m) * ((b - a_m) * (2.0 * sin(((((angle_m * (pi + 1.0)) * (180.0 / angle_m)) - 180.0) / (32400.0 / angle_m))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[N[(angle$95$m / 180.0), $MachinePrecision], 1e+139], N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(b + a$95$m), $MachinePrecision] * N[Sin[N[(N[(Pi * angle$95$m), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(N[(N[(N[(angle$95$m * N[(Pi + 1.0), $MachinePrecision]), $MachinePrecision] * N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision] - 180.0), $MachinePrecision] / N[(32400.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;\frac{angle\_m}{180} \leq 10^{+139}:\\
\;\;\;\;\left(b - a\_m\right) \cdot \left(\left(b + a\_m\right) \cdot \sin \left(\left(\pi \cdot angle\_m\right) \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(\frac{\left(angle\_m \cdot \left(\pi + 1\right)\right) \cdot \frac{180}{angle\_m} - 180}{\frac{32400}{angle\_m}}\right)\right)\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 1.00000000000000003e139Initial program 55.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified55.7%
associate-*r*N/A
*-commutativeN/A
associate-*r/N/A
associate-*l*N/A
*-commutativeN/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
Applied egg-rr68.0%
if 1.00000000000000003e139 < (/.f64 angle #s(literal 180 binary64)) Initial program 16.0%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified12.8%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr24.7%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr28.9%
Taylor expanded in angle around 0
Simplified34.6%
Final simplification63.1%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 1.95e+141)
(* (- b a_m) (* (+ b a_m) (sin (* (* PI angle_m) 0.011111111111111112))))
(* (+ b a_m) (* (- b a_m) (* 2.0 (sin (/ PI (/ 180.0 angle_m)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.95e+141) {
tmp = (b - a_m) * ((b + a_m) * sin(((((double) M_PI) * angle_m) * 0.011111111111111112)));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * sin((((double) M_PI) / (180.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.95e+141) {
tmp = (b - a_m) * ((b + a_m) * Math.sin(((Math.PI * angle_m) * 0.011111111111111112)));
} else {
tmp = (b + a_m) * ((b - a_m) * (2.0 * Math.sin((Math.PI / (180.0 / angle_m)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 1.95e+141: tmp = (b - a_m) * ((b + a_m) * math.sin(((math.pi * angle_m) * 0.011111111111111112))) else: tmp = (b + a_m) * ((b - a_m) * (2.0 * math.sin((math.pi / (180.0 / angle_m))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 1.95e+141) tmp = Float64(Float64(b - a_m) * Float64(Float64(b + a_m) * sin(Float64(Float64(pi * angle_m) * 0.011111111111111112)))); else tmp = Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(pi / Float64(180.0 / angle_m)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 1.95e+141) tmp = (b - a_m) * ((b + a_m) * sin(((pi * angle_m) * 0.011111111111111112))); else tmp = (b + a_m) * ((b - a_m) * (2.0 * sin((pi / (180.0 / angle_m))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 1.95e+141], N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(b + a$95$m), $MachinePrecision] * N[Sin[N[(N[(Pi * angle$95$m), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(Pi / N[(180.0 / angle$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 1.95 \cdot 10^{+141}:\\
\;\;\;\;\left(b - a\_m\right) \cdot \left(\left(b + a\_m\right) \cdot \sin \left(\left(\pi \cdot angle\_m\right) \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(\frac{\pi}{\frac{180}{angle\_m}}\right)\right)\right)\\
\end{array}
\end{array}
if angle < 1.94999999999999996e141Initial program 55.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified55.7%
associate-*r*N/A
*-commutativeN/A
associate-*r/N/A
associate-*l*N/A
*-commutativeN/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
Applied egg-rr68.0%
if 1.94999999999999996e141 < angle Initial program 16.0%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified12.8%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr24.7%
Taylor expanded in angle around 0
--lowering--.f6431.1%
Simplified31.1%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= b 3.1e+131)
(* (- b a_m) (* (+ b a_m) (sin (* (* PI angle_m) 0.011111111111111112))))
(*
(+ b a_m)
(*
6.17283950617284e-5
(* (* angle_m (- b a_m)) (+ 180.0 (+ -180.0 (* 180.0 PI)))))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 3.1e+131) {
tmp = (b - a_m) * ((b + a_m) * sin(((((double) M_PI) * angle_m) * 0.011111111111111112)));
} else {
tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * ((double) M_PI))))));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (b <= 3.1e+131) {
tmp = (b - a_m) * ((b + a_m) * Math.sin(((Math.PI * angle_m) * 0.011111111111111112)));
} else {
tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * Math.PI)))));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if b <= 3.1e+131: tmp = (b - a_m) * ((b + a_m) * math.sin(((math.pi * angle_m) * 0.011111111111111112))) else: tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * math.pi))))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (b <= 3.1e+131) tmp = Float64(Float64(b - a_m) * Float64(Float64(b + a_m) * sin(Float64(Float64(pi * angle_m) * 0.011111111111111112)))); else tmp = Float64(Float64(b + a_m) * Float64(6.17283950617284e-5 * Float64(Float64(angle_m * Float64(b - a_m)) * Float64(180.0 + Float64(-180.0 + Float64(180.0 * pi)))))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (b <= 3.1e+131) tmp = (b - a_m) * ((b + a_m) * sin(((pi * angle_m) * 0.011111111111111112))); else tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * pi))))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[b, 3.1e+131], N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(b + a$95$m), $MachinePrecision] * N[Sin[N[(N[(Pi * angle$95$m), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a$95$m), $MachinePrecision] * N[(6.17283950617284e-5 * N[(N[(angle$95$m * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(180.0 + N[(-180.0 + N[(180.0 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;b \leq 3.1 \cdot 10^{+131}:\\
\;\;\;\;\left(b - a\_m\right) \cdot \left(\left(b + a\_m\right) \cdot \sin \left(\left(\pi \cdot angle\_m\right) \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(6.17283950617284 \cdot 10^{-5} \cdot \left(\left(angle\_m \cdot \left(b - a\_m\right)\right) \cdot \left(180 + \left(-180 + 180 \cdot \pi\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 3.10000000000000016e131Initial program 51.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified51.2%
associate-*r*N/A
*-commutativeN/A
associate-*r/N/A
associate-*l*N/A
*-commutativeN/A
difference-of-squaresN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
Applied egg-rr58.3%
if 3.10000000000000016e131 < b Initial program 38.7%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified39.1%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr72.7%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr77.8%
Taylor expanded in angle around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
distribute-lft-inN/A
metadata-evalN/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
metadata-eval67.9%
Simplified67.9%
Final simplification59.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0 (* PI (- b a_m))))
(*
angle_s
(if (<= angle_m 1.8e+82)
(*
(+ b a_m)
(*
6.17283950617284e-5
(* (* angle_m (- b a_m)) (+ 180.0 (+ -180.0 (* 180.0 PI))))))
(if (<= angle_m 2.25e+148)
(*
(+ b a_m)
(*
angle_m
(+
(* 0.011111111111111112 t_0)
(*
(* 2.0 (* angle_m angle_m))
(* (- b a_m) (* (* PI (* PI PI)) -1.1431184270690443e-7))))))
(* (* (+ b a_m) t_0) (* angle_m 0.011111111111111112)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = ((double) M_PI) * (b - a_m);
double tmp;
if (angle_m <= 1.8e+82) {
tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * ((double) M_PI))))));
} else if (angle_m <= 2.25e+148) {
tmp = (b + a_m) * (angle_m * ((0.011111111111111112 * t_0) + ((2.0 * (angle_m * angle_m)) * ((b - a_m) * ((((double) M_PI) * (((double) M_PI) * ((double) M_PI))) * -1.1431184270690443e-7)))));
} else {
tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = Math.PI * (b - a_m);
double tmp;
if (angle_m <= 1.8e+82) {
tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * Math.PI)))));
} else if (angle_m <= 2.25e+148) {
tmp = (b + a_m) * (angle_m * ((0.011111111111111112 * t_0) + ((2.0 * (angle_m * angle_m)) * ((b - a_m) * ((Math.PI * (Math.PI * Math.PI)) * -1.1431184270690443e-7)))));
} else {
tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = math.pi * (b - a_m) tmp = 0 if angle_m <= 1.8e+82: tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * math.pi))))) elif angle_m <= 2.25e+148: tmp = (b + a_m) * (angle_m * ((0.011111111111111112 * t_0) + ((2.0 * (angle_m * angle_m)) * ((b - a_m) * ((math.pi * (math.pi * math.pi)) * -1.1431184270690443e-7))))) else: tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(pi * Float64(b - a_m)) tmp = 0.0 if (angle_m <= 1.8e+82) tmp = Float64(Float64(b + a_m) * Float64(6.17283950617284e-5 * Float64(Float64(angle_m * Float64(b - a_m)) * Float64(180.0 + Float64(-180.0 + Float64(180.0 * pi)))))); elseif (angle_m <= 2.25e+148) tmp = Float64(Float64(b + a_m) * Float64(angle_m * Float64(Float64(0.011111111111111112 * t_0) + Float64(Float64(2.0 * Float64(angle_m * angle_m)) * Float64(Float64(b - a_m) * Float64(Float64(pi * Float64(pi * pi)) * -1.1431184270690443e-7)))))); else tmp = Float64(Float64(Float64(b + a_m) * t_0) * Float64(angle_m * 0.011111111111111112)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = pi * (b - a_m); tmp = 0.0; if (angle_m <= 1.8e+82) tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * pi))))); elseif (angle_m <= 2.25e+148) tmp = (b + a_m) * (angle_m * ((0.011111111111111112 * t_0) + ((2.0 * (angle_m * angle_m)) * ((b - a_m) * ((pi * (pi * pi)) * -1.1431184270690443e-7))))); else tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 1.8e+82], N[(N[(b + a$95$m), $MachinePrecision] * N[(6.17283950617284e-5 * N[(N[(angle$95$m * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(180.0 + N[(-180.0 + N[(180.0 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle$95$m, 2.25e+148], N[(N[(b + a$95$m), $MachinePrecision] * N[(angle$95$m * N[(N[(0.011111111111111112 * t$95$0), $MachinePrecision] + N[(N[(2.0 * N[(angle$95$m * angle$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(Pi * N[(Pi * Pi), $MachinePrecision]), $MachinePrecision] * -1.1431184270690443e-7), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b + a$95$m), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \pi \cdot \left(b - a\_m\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 1.8 \cdot 10^{+82}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(6.17283950617284 \cdot 10^{-5} \cdot \left(\left(angle\_m \cdot \left(b - a\_m\right)\right) \cdot \left(180 + \left(-180 + 180 \cdot \pi\right)\right)\right)\right)\\
\mathbf{elif}\;angle\_m \leq 2.25 \cdot 10^{+148}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(angle\_m \cdot \left(0.011111111111111112 \cdot t\_0 + \left(2 \cdot \left(angle\_m \cdot angle\_m\right)\right) \cdot \left(\left(b - a\_m\right) \cdot \left(\left(\pi \cdot \left(\pi \cdot \pi\right)\right) \cdot -1.1431184270690443 \cdot 10^{-7}\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot t\_0\right) \cdot \left(angle\_m \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
\end{array}
if angle < 1.80000000000000007e82Initial program 57.2%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified57.0%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr69.0%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr70.5%
Taylor expanded in angle around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
distribute-lft-inN/A
metadata-evalN/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
metadata-eval64.9%
Simplified64.9%
if 1.80000000000000007e82 < angle < 2.24999999999999997e148Initial program 26.6%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified33.6%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr33.6%
Taylor expanded in angle around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
Simplified28.2%
if 2.24999999999999997e148 < angle Initial program 16.4%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified13.1%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6425.9%
Simplified25.9%
*-lowering-*.f64N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
*-lowering-*.f6425.9%
Applied egg-rr25.9%
Final simplification57.1%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 5.8e+78)
(*
(+ b a_m)
(*
6.17283950617284e-5
(* (* angle_m (- b a_m)) (+ 180.0 (+ -180.0 (* 180.0 PI))))))
(*
(* (* b b) (- PI (* PI (/ (/ (* a_m a_m) b) b))))
(* angle_m 0.011111111111111112)))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 5.8e+78) {
tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * ((double) M_PI))))));
} else {
tmp = ((b * b) * (((double) M_PI) - (((double) M_PI) * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 5.8e+78) {
tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * Math.PI)))));
} else {
tmp = ((b * b) * (Math.PI - (Math.PI * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 5.8e+78: tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * math.pi))))) else: tmp = ((b * b) * (math.pi - (math.pi * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 5.8e+78) tmp = Float64(Float64(b + a_m) * Float64(6.17283950617284e-5 * Float64(Float64(angle_m * Float64(b - a_m)) * Float64(180.0 + Float64(-180.0 + Float64(180.0 * pi)))))); else tmp = Float64(Float64(Float64(b * b) * Float64(pi - Float64(pi * Float64(Float64(Float64(a_m * a_m) / b) / b)))) * Float64(angle_m * 0.011111111111111112)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 5.8e+78) tmp = (b + a_m) * (6.17283950617284e-5 * ((angle_m * (b - a_m)) * (180.0 + (-180.0 + (180.0 * pi))))); else tmp = ((b * b) * (pi - (pi * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 5.8e+78], N[(N[(b + a$95$m), $MachinePrecision] * N[(6.17283950617284e-5 * N[(N[(angle$95$m * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(180.0 + N[(-180.0 + N[(180.0 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b * b), $MachinePrecision] * N[(Pi - N[(Pi * N[(N[(N[(a$95$m * a$95$m), $MachinePrecision] / b), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 5.8 \cdot 10^{+78}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(6.17283950617284 \cdot 10^{-5} \cdot \left(\left(angle\_m \cdot \left(b - a\_m\right)\right) \cdot \left(180 + \left(-180 + 180 \cdot \pi\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b \cdot b\right) \cdot \left(\pi - \pi \cdot \frac{\frac{a\_m \cdot a\_m}{b}}{b}\right)\right) \cdot \left(angle\_m \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if angle < 5.80000000000000034e78Initial program 57.7%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified57.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr69.5%
expm1-log1p-uN/A
expm1-undefineN/A
log1p-undefineN/A
+-commutativeN/A
rem-exp-logN/A
sub-divN/A
associate-/r/N/A
associate-*l/N/A
frac-subN/A
*-commutativeN/A
/-lowering-/.f64N/A
Applied egg-rr71.1%
Taylor expanded in angle around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
distribute-lft-inN/A
metadata-evalN/A
associate--l+N/A
+-lowering-+.f64N/A
sub-negN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
metadata-eval65.5%
Simplified65.5%
if 5.80000000000000034e78 < angle Initial program 19.0%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified18.7%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6422.2%
Simplified22.2%
Taylor expanded in b around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6424.2%
Simplified24.2%
Final simplification56.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= angle_m 1.12e+79)
(* (+ b a_m) (* 0.011111111111111112 (* angle_m (* PI (- b a_m)))))
(*
(* (* b b) (- PI (* PI (/ (/ (* a_m a_m) b) b))))
(* angle_m 0.011111111111111112)))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.12e+79) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * (((double) M_PI) * (b - a_m))));
} else {
tmp = ((b * b) * (((double) M_PI) - (((double) M_PI) * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (angle_m <= 1.12e+79) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * (Math.PI * (b - a_m))));
} else {
tmp = ((b * b) * (Math.PI - (Math.PI * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if angle_m <= 1.12e+79: tmp = (b + a_m) * (0.011111111111111112 * (angle_m * (math.pi * (b - a_m)))) else: tmp = ((b * b) * (math.pi - (math.pi * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (angle_m <= 1.12e+79) tmp = Float64(Float64(b + a_m) * Float64(0.011111111111111112 * Float64(angle_m * Float64(pi * Float64(b - a_m))))); else tmp = Float64(Float64(Float64(b * b) * Float64(pi - Float64(pi * Float64(Float64(Float64(a_m * a_m) / b) / b)))) * Float64(angle_m * 0.011111111111111112)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (angle_m <= 1.12e+79) tmp = (b + a_m) * (0.011111111111111112 * (angle_m * (pi * (b - a_m)))); else tmp = ((b * b) * (pi - (pi * (((a_m * a_m) / b) / b)))) * (angle_m * 0.011111111111111112); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[angle$95$m, 1.12e+79], N[(N[(b + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b * b), $MachinePrecision] * N[(Pi - N[(Pi * N[(N[(N[(a$95$m * a$95$m), $MachinePrecision] / b), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 1.12 \cdot 10^{+79}:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot \left(\pi \cdot \left(b - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b \cdot b\right) \cdot \left(\pi - \pi \cdot \frac{\frac{a\_m \cdot a\_m}{b}}{b}\right)\right) \cdot \left(angle\_m \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if angle < 1.12e79Initial program 57.7%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified57.5%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr69.5%
Taylor expanded in angle around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f6465.5%
Simplified65.5%
if 1.12e79 < angle Initial program 19.0%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified18.7%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6422.2%
Simplified22.2%
Taylor expanded in b around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6424.2%
Simplified24.2%
Final simplification56.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(let* ((t_0 (* PI (- b a_m))))
(*
angle_s
(if (<= angle_m 400.0)
(* (+ b a_m) (* 0.011111111111111112 (* angle_m t_0)))
(* (* (+ b a_m) t_0) (* angle_m 0.011111111111111112))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = ((double) M_PI) * (b - a_m);
double tmp;
if (angle_m <= 400.0) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * t_0));
} else {
tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double t_0 = Math.PI * (b - a_m);
double tmp;
if (angle_m <= 400.0) {
tmp = (b + a_m) * (0.011111111111111112 * (angle_m * t_0));
} else {
tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): t_0 = math.pi * (b - a_m) tmp = 0 if angle_m <= 400.0: tmp = (b + a_m) * (0.011111111111111112 * (angle_m * t_0)) else: tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) t_0 = Float64(pi * Float64(b - a_m)) tmp = 0.0 if (angle_m <= 400.0) tmp = Float64(Float64(b + a_m) * Float64(0.011111111111111112 * Float64(angle_m * t_0))); else tmp = Float64(Float64(Float64(b + a_m) * t_0) * Float64(angle_m * 0.011111111111111112)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) t_0 = pi * (b - a_m); tmp = 0.0; if (angle_m <= 400.0) tmp = (b + a_m) * (0.011111111111111112 * (angle_m * t_0)); else tmp = ((b + a_m) * t_0) * (angle_m * 0.011111111111111112); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := Block[{t$95$0 = N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]}, N[(angle$95$s * If[LessEqual[angle$95$m, 400.0], N[(N[(b + a$95$m), $MachinePrecision] * N[(0.011111111111111112 * N[(angle$95$m * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b + a$95$m), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(angle$95$m * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
\begin{array}{l}
t_0 := \pi \cdot \left(b - a\_m\right)\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;angle\_m \leq 400:\\
\;\;\;\;\left(b + a\_m\right) \cdot \left(0.011111111111111112 \cdot \left(angle\_m \cdot t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot t\_0\right) \cdot \left(angle\_m \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
\end{array}
if angle < 400Initial program 61.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified61.1%
associate-*r*N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*r/N/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
Applied egg-rr75.2%
Taylor expanded in angle around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f6469.9%
Simplified69.9%
if 400 < angle Initial program 22.1%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified22.4%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6425.6%
Simplified25.6%
*-lowering-*.f64N/A
*-commutativeN/A
difference-of-squaresN/A
associate-*l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
*-lowering-*.f6426.9%
Applied egg-rr26.9%
Final simplification56.8%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= a_m 5.2e+150)
(* angle_m (* PI (* 0.011111111111111112 (- (* b b) (* a_m a_m)))))
(* -0.011111111111111112 (* a_m (* a_m (* PI angle_m)))))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (a_m <= 5.2e+150) {
tmp = angle_m * (((double) M_PI) * (0.011111111111111112 * ((b * b) - (a_m * a_m))));
} else {
tmp = -0.011111111111111112 * (a_m * (a_m * (((double) M_PI) * angle_m)));
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (a_m <= 5.2e+150) {
tmp = angle_m * (Math.PI * (0.011111111111111112 * ((b * b) - (a_m * a_m))));
} else {
tmp = -0.011111111111111112 * (a_m * (a_m * (Math.PI * angle_m)));
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if a_m <= 5.2e+150: tmp = angle_m * (math.pi * (0.011111111111111112 * ((b * b) - (a_m * a_m)))) else: tmp = -0.011111111111111112 * (a_m * (a_m * (math.pi * angle_m))) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (a_m <= 5.2e+150) tmp = Float64(angle_m * Float64(pi * Float64(0.011111111111111112 * Float64(Float64(b * b) - Float64(a_m * a_m))))); else tmp = Float64(-0.011111111111111112 * Float64(a_m * Float64(a_m * Float64(pi * angle_m)))); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (a_m <= 5.2e+150) tmp = angle_m * (pi * (0.011111111111111112 * ((b * b) - (a_m * a_m)))); else tmp = -0.011111111111111112 * (a_m * (a_m * (pi * angle_m))); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[a$95$m, 5.2e+150], N[(angle$95$m * N[(Pi * N[(0.011111111111111112 * N[(N[(b * b), $MachinePrecision] - N[(a$95$m * a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-0.011111111111111112 * N[(a$95$m * N[(a$95$m * N[(Pi * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 5.2 \cdot 10^{+150}:\\
\;\;\;\;angle\_m \cdot \left(\pi \cdot \left(0.011111111111111112 \cdot \left(b \cdot b - a\_m \cdot a\_m\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;-0.011111111111111112 \cdot \left(a\_m \cdot \left(a\_m \cdot \left(\pi \cdot angle\_m\right)\right)\right)\\
\end{array}
\end{array}
if a < 5.20000000000000012e150Initial program 49.9%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified50.1%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6448.5%
Simplified48.5%
associate-*r*N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6448.6%
Applied egg-rr48.6%
if 5.20000000000000012e150 < a Initial program 45.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified41.2%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6448.9%
Simplified48.9%
Taylor expanded in b around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6466.3%
Simplified66.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6482.4%
Applied egg-rr82.4%
Final simplification51.6%
a_m = (fabs.f64 a)
angle\_m = (fabs.f64 angle)
angle\_s = (copysign.f64 #s(literal 1 binary64) angle)
(FPCore (angle_s a_m b angle_m)
:precision binary64
(*
angle_s
(if (<= a_m 8.2e+39)
(* (* angle_m 0.011111111111111112) (* PI (* b b)))
(* (* angle_m (* a_m PI)) (* a_m -0.011111111111111112)))))a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (a_m <= 8.2e+39) {
tmp = (angle_m * 0.011111111111111112) * (((double) M_PI) * (b * b));
} else {
tmp = (angle_m * (a_m * ((double) M_PI))) * (a_m * -0.011111111111111112);
}
return angle_s * tmp;
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
double tmp;
if (a_m <= 8.2e+39) {
tmp = (angle_m * 0.011111111111111112) * (Math.PI * (b * b));
} else {
tmp = (angle_m * (a_m * Math.PI)) * (a_m * -0.011111111111111112);
}
return angle_s * tmp;
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): tmp = 0 if a_m <= 8.2e+39: tmp = (angle_m * 0.011111111111111112) * (math.pi * (b * b)) else: tmp = (angle_m * (a_m * math.pi)) * (a_m * -0.011111111111111112) return angle_s * tmp
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) tmp = 0.0 if (a_m <= 8.2e+39) tmp = Float64(Float64(angle_m * 0.011111111111111112) * Float64(pi * Float64(b * b))); else tmp = Float64(Float64(angle_m * Float64(a_m * pi)) * Float64(a_m * -0.011111111111111112)); end return Float64(angle_s * tmp) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp_2 = code(angle_s, a_m, b, angle_m) tmp = 0.0; if (a_m <= 8.2e+39) tmp = (angle_m * 0.011111111111111112) * (pi * (b * b)); else tmp = (angle_m * (a_m * pi)) * (a_m * -0.011111111111111112); end tmp_2 = angle_s * tmp; end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * If[LessEqual[a$95$m, 8.2e+39], N[(N[(angle$95$m * 0.011111111111111112), $MachinePrecision] * N[(Pi * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(angle$95$m * N[(a$95$m * Pi), $MachinePrecision]), $MachinePrecision] * N[(a$95$m * -0.011111111111111112), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \begin{array}{l}
\mathbf{if}\;a\_m \leq 8.2 \cdot 10^{+39}:\\
\;\;\;\;\left(angle\_m \cdot 0.011111111111111112\right) \cdot \left(\pi \cdot \left(b \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(angle\_m \cdot \left(a\_m \cdot \pi\right)\right) \cdot \left(a\_m \cdot -0.011111111111111112\right)\\
\end{array}
\end{array}
if a < 8.20000000000000008e39Initial program 50.4%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified50.9%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6449.3%
Simplified49.3%
Taylor expanded in b around inf
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
unpow2N/A
*-lowering-*.f6441.0%
Simplified41.0%
if 8.20000000000000008e39 < a Initial program 45.3%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified42.1%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6445.1%
Simplified45.1%
Taylor expanded in b around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6451.5%
Simplified51.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6459.6%
Applied egg-rr59.6%
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
*-lowering-*.f6459.7%
Applied egg-rr59.7%
Final simplification44.4%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* (* angle_m (* a_m PI)) (* a_m -0.011111111111111112))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((angle_m * (a_m * ((double) M_PI))) * (a_m * -0.011111111111111112));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * ((angle_m * (a_m * Math.PI)) * (a_m * -0.011111111111111112));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * ((angle_m * (a_m * math.pi)) * (a_m * -0.011111111111111112))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(Float64(angle_m * Float64(a_m * pi)) * Float64(a_m * -0.011111111111111112))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * ((angle_m * (a_m * pi)) * (a_m * -0.011111111111111112)); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(N[(angle$95$m * N[(a$95$m * Pi), $MachinePrecision]), $MachinePrecision] * N[(a$95$m * -0.011111111111111112), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(\left(angle\_m \cdot \left(a\_m \cdot \pi\right)\right) \cdot \left(a\_m \cdot -0.011111111111111112\right)\right)
\end{array}
Initial program 49.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified49.3%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6448.5%
Simplified48.5%
Taylor expanded in b around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6435.4%
Simplified35.4%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6436.1%
Applied egg-rr36.1%
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
*-lowering-*.f6436.1%
Applied egg-rr36.1%
Final simplification36.1%
a_m = (fabs.f64 a) angle\_m = (fabs.f64 angle) angle\_s = (copysign.f64 #s(literal 1 binary64) angle) (FPCore (angle_s a_m b angle_m) :precision binary64 (* angle_s (* -0.011111111111111112 (* a_m (* a_m (* PI angle_m))))))
a_m = fabs(a);
angle\_m = fabs(angle);
angle\_s = copysign(1.0, angle);
double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (a_m * (a_m * (((double) M_PI) * angle_m))));
}
a_m = Math.abs(a);
angle\_m = Math.abs(angle);
angle\_s = Math.copySign(1.0, angle);
public static double code(double angle_s, double a_m, double b, double angle_m) {
return angle_s * (-0.011111111111111112 * (a_m * (a_m * (Math.PI * angle_m))));
}
a_m = math.fabs(a) angle\_m = math.fabs(angle) angle\_s = math.copysign(1.0, angle) def code(angle_s, a_m, b, angle_m): return angle_s * (-0.011111111111111112 * (a_m * (a_m * (math.pi * angle_m))))
a_m = abs(a) angle\_m = abs(angle) angle\_s = copysign(1.0, angle) function code(angle_s, a_m, b, angle_m) return Float64(angle_s * Float64(-0.011111111111111112 * Float64(a_m * Float64(a_m * Float64(pi * angle_m))))) end
a_m = abs(a); angle\_m = abs(angle); angle\_s = sign(angle) * abs(1.0); function tmp = code(angle_s, a_m, b, angle_m) tmp = angle_s * (-0.011111111111111112 * (a_m * (a_m * (pi * angle_m)))); end
a_m = N[Abs[a], $MachinePrecision]
angle\_m = N[Abs[angle], $MachinePrecision]
angle\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[angle$95$s_, a$95$m_, b_, angle$95$m_] := N[(angle$95$s * N[(-0.011111111111111112 * N[(a$95$m * N[(a$95$m * N[(Pi * angle$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
angle\_m = \left|angle\right|
\\
angle\_s = \mathsf{copysign}\left(1, angle\right)
\\
angle\_s \cdot \left(-0.011111111111111112 \cdot \left(a\_m \cdot \left(a\_m \cdot \left(\pi \cdot angle\_m\right)\right)\right)\right)
\end{array}
Initial program 49.5%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified49.3%
Taylor expanded in angle around 0
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f64N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6448.5%
Simplified48.5%
Taylor expanded in b around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6435.4%
Simplified35.4%
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
PI-lowering-PI.f6436.1%
Applied egg-rr36.1%
herbie shell --seed 2024163
(FPCore (a b angle)
:name "ab-angle->ABCF B"
:precision binary64
(* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin (* PI (/ angle 180.0)))) (cos (* PI (/ angle 180.0)))))